ooxml-core 1.2.1 → 1.3.0

package/dist/automation/index.cjs

@@ -259,14 +259,14 @@ function startTag(source2, from, namespaces) {
     while (q < n && isSpace(source2.charCodeAt(q))) q++;
     const quote2 = source2[q];
     if (quote2 !== '"' && quote2 !== "'") return void 0;
-    const close = source2.indexOf(quote2, q + 1);
-    if (close < 0) return void 0;
-    const raw2 = source2.slice(q + 1, close);
+    const close2 = source2.indexOf(quote2, q + 1);
+    if (close2 < 0) return void 0;
+    const raw2 = source2.slice(q + 1, close2);
     if (raw2.includes("<") || element2.hasAttribute(name)) return void 0;
     const value = decode(/[\t\n\r]/.test(raw2) ? raw2.replace(/[\t\n\r]/g, " ") : raw2);
     if (value === void 0) return void 0;
     element2.attrs.push(name, value);
-    i2 = close + 1;
+    i2 = close2 + 1;
     const after = source2.charCodeAt(i2);
     if (i2 < n && !isSpace(after) && after !== 62 && after !== 47) return void 0;
   }
@@ -2237,12 +2237,12 @@ function linearToSrgb255(linear) {
 // color/hex-rgb.ts
 function parseArgbHex(hex) {
   const clean3 = hex.replace(/^#/, "");
-  const rgb2 = clean3.length === 8 ? clean3.slice(2) : clean3;
-  if (!/^[0-9a-fA-F]{6}$/.test(rgb2)) return void 0;
-  return [0, 2, 4].map((i2) => parseInt(rgb2.slice(i2, i2 + 2), 16));
+  const rgb3 = clean3.length === 8 ? clean3.slice(2) : clean3;
+  if (!/^[0-9a-fA-F]{6}$/.test(rgb3)) return void 0;
+  return [0, 2, 4].map((i2) => parseInt(rgb3.slice(i2, i2 + 2), 16));
 }
 var clamp255 = (v) => Math.max(0, Math.min(255, v));
-var rgbToUpperHex = (rgb2) => `#${rgb2.map((v) => clamp255(Math.round(v)).toString(16).padStart(2, "0")).join("").toUpperCase()}`;
+var rgbToUpperHex = (rgb3) => `#${rgb3.map((v) => clamp255(Math.round(v)).toString(16).padStart(2, "0")).join("").toUpperCase()}`;
 
 // drawingml/theme-model.ts
 var THEME_COLOR_SLOTS = [
@@ -4570,10 +4570,10 @@ var APPLIED = /* @__PURE__ */ new Set([
 ]);
 function resolveDrawingColor(color2, theme2, options) {
   const base = baseHex(color2, theme2);
-  const rgb2 = base ? hexToRgbChannels(base) : null;
-  if (!rgb2) return void 0;
+  const rgb3 = base ? hexToRgbChannels(base) : null;
+  if (!rgb3) return void 0;
   {
-    const value = orderedColorTransforms(rgb2, color2.transforms);
+    const value = orderedColorTransforms(rgb3, color2.transforms);
     const round3 = options.hslRounding === "halfDown" ? (channel) => Math.ceil(channel - 0.5) : Math.round;
     return {
       hex: `#${toHex(round3(value.r))}${toHex(round3(value.g))}${toHex(round3(value.b))}`,
@@ -11977,10 +11977,10 @@ function parseDynamicArrayMetadata(xml) {
 function parseColor(element2, palette) {
   if (!element2) return void 0;
   const color2 = {};
-  const rgb2 = att(element2, "rgb");
+  const rgb3 = att(element2, "rgb");
   const theme2 = numAttr(element2, "theme");
   const indexed = numAttr(element2, "indexed");
-  if (rgb2 && /^[0-9A-Fa-f]{6}([0-9A-Fa-f]{2})?$/.test(rgb2)) color2.rgb = rgb2.toUpperCase();
+  if (rgb3 && /^[0-9A-Fa-f]{6}([0-9A-Fa-f]{2})?$/.test(rgb3)) color2.rgb = rgb3.toUpperCase();
   else if (theme2 !== void 0) color2.theme = theme2;
   else if (indexed !== void 0) {
     const override = palette?.[indexed];
@@ -12658,14 +12658,13 @@ function splitSheets(text2) {
   if (book !== void 0) out.book = book;
   return out;
 }
-var PREFIX_AT = /(\[\d+\])?([A-Za-z0-9_.\u00A1-\uFFFF]+)(?::([A-Za-z0-9_.\u00A1-\uFFFF]+))?!/y;
 function readPrefix(source2, at2) {
   const ch = source2[at2];
   if (ch === "'") {
     const quoted = readQuoted(source2, at2);
     if (source2[at2 + quoted.length] !== "!") return void 0;
-    const length = quoted.length + 1;
-    return { prefix: { text: source2.slice(at2, at2 + length), ...splitSheets(quoted.name) }, length };
+    const length2 = quoted.length + 1;
+    return { prefix: { text: source2.slice(at2, at2 + length2), ...splitSheets(quoted.name) }, length: length2 };
   }
   let i2 = at2;
   if (ch === "[") {
@@ -12674,13 +12673,23 @@ function readPrefix(source2, at2) {
     if (i2 === at2 + 1 || source2[i2] !== "]") return void 0;
     i2++;
   }
+  const sheetFrom = i2;
   while (i2 < source2.length && isSheetCharCode(source2.charCodeAt(i2))) i2++;
-  if (source2[i2] !== "!" && source2[i2] !== ":") return void 0;
-  const m = matchAt(PREFIX_AT, source2, at2);
-  if (!m) return void 0;
-  if (!m[1] && /^\d/.test(m[2] ?? "") && !m[3]) return void 0;
-  const raw2 = m[0].slice(0, -1);
-  return { prefix: { text: m[0], ...splitSheets(raw2) }, length: m[0].length };
+  if (i2 === sheetFrom) return void 0;
+  let lastFrom = -1;
+  if (source2[i2] === ":") {
+    lastFrom = i2 + 1;
+    i2 = lastFrom;
+    while (i2 < source2.length && isSheetCharCode(source2.charCodeAt(i2))) i2++;
+    if (i2 === lastFrom) return void 0;
+  }
+  if (source2[i2] !== "!") return void 0;
+  if (ch !== "[" && lastFrom < 0 && isDigitCode(source2.charCodeAt(sheetFrom))) return void 0;
+  const length = i2 + 1 - at2;
+  return {
+    prefix: { text: source2.slice(at2, at2 + length), ...splitSheets(source2.slice(at2, i2)) },
+    length
+  };
 }
 function numberLiteral(text2) {
   if (text2.length <= 15) return Number(text2);
@@ -13118,14 +13127,14 @@ function fromStoredSyntax(formula) {
     if (name !== "ANCHORARRAY" && name !== "SINGLE") continue;
     const open = nextIndex(list, i2 + 1);
     const arg = nextIndex(list, open + 1);
-    const close = nextIndex(list, arg + 1);
+    const close2 = nextIndex(list, arg + 1);
     const target = list[arg];
-    if (list[open]?.kind !== "open" || list[close]?.kind !== "close" || !target) continue;
+    if (list[open]?.kind !== "open" || list[close2]?.kind !== "close" || !target) continue;
     const single = target.kind === "ref" || target.kind === "name" || target.kind === "structured";
     if (name === "ANCHORARRAY" && !(target.kind === "ref" && target.ref?.kind === "cell")) continue;
     if (name === "SINGLE" && !single) continue;
     const text2 = name === "ANCHORARRAY" ? `${target.text}#` : `@${target.text}`;
-    for (let k = i2; k <= close; k++) list[k].text = "";
+    for (let k = i2; k <= close2; k++) list[k].text = "";
     token.text = text2;
     changed = true;
   }
@@ -14473,12 +14482,12 @@ function splitSheetData(xml) {
   if (openEnd < 0) return void 0;
   const attributes = xml.slice(open.index + tagName2.length + 1, openEnd);
   if (attributes.trimEnd().endsWith("/") || attributes.includes("xmlns")) return void 0;
-  const close = xml.indexOf(`</${tagName2}`, openEnd);
-  if (close < 0 || OPEN.test(xml.slice(openEnd))) return void 0;
+  const close2 = xml.indexOf(`</${tagName2}`, openEnd);
+  if (close2 < 0 || OPEN.test(xml.slice(openEnd))) return void 0;
   const container = new LiteElement(tagName2, "sheetData", ns || null);
-  const data = parseLiteFragment(xml.slice(openEnd + 1, close), container, namespaces);
+  const data = parseLiteFragment(xml.slice(openEnd + 1, close2), container, namespaces);
   if (!data) return void 0;
-  return { xml: xml.slice(0, openEnd + 1) + xml.slice(close), sheetData: data.asElement() };
+  return { xml: xml.slice(0, openEnd + 1) + xml.slice(close2), sheetData: data.asElement() };
 }
 
 // xlsx/read/print-options.ts
@@ -15021,10 +15030,10 @@ function hls240ToRgb({ h: h2, l, s }) {
 var parseHex = parseArgbHex;
 var toHexColor = rgbToUpperHex;
 function applyTint(hex, tint) {
-  const rgb2 = parseHex(hex) ?? [0, 0, 0];
-  if (!tint) return toHexColor(rgb2);
+  const rgb3 = parseHex(hex) ?? [0, 0, 0];
+  if (!tint) return toHexColor(rgb3);
   const t = Math.max(-1, Math.min(1, tint));
-  const hls = rgbToHls240(...rgb2);
+  const hls = rgbToHls240(...rgb3);
   const l = t < 0 ? Math.trunc(hls.l * (1 + t)) : Math.round(hls.l * (1 - t) + HLSMAX * t);
   return toHexColor(hls240ToRgb({ ...hls, l: Math.max(0, Math.min(HLSMAX, l)) }));
 }
@@ -27893,8 +27902,8 @@ var Engine = class extends EngineStructure {
   evaluate(formula, at2) {
     const value = this.evaluateAdHoc(formula, at2);
     const frame = this.frameFor(at2.sheet, at2.row, at2.col, void 0);
-    const scalar3 = implicitIntersection(value, frame);
-    return typeof scalar3 === "number" && !Number.isFinite(scalar3) ? ERR.NUM : scalar3;
+    const scalar4 = implicitIntersection(value, frame);
+    return typeof scalar4 === "number" && !Number.isFinite(scalar4) ? ERR.NUM : scalar4;
   }
   evaluateArray(formula, at2) {
     const value = this.evaluateAdHoc(formula, at2);
@@ -28358,7 +28367,7 @@ var attrPattern = (name) => new RegExp(`(\\s${name}\\s*=\\s*)(["'])(.*?)\\2`);
 function patchWorksheetSource(xml, edits) {
   const match2 = WORKSHEET_SOURCE.exec(xml);
   if (!match2) return xml;
-  const [whole, tag, attrs2 = "", close] = match2;
+  const [whole, tag, attrs2 = "", close2] = match2;
   if (/\sr:id\s*=/.test(attrs2)) return xml;
   const sheetMatch = attrPattern("sheet").exec(attrs2);
   const refMatch = attrPattern("ref").exec(attrs2);
@@ -28382,7 +28391,7 @@ function patchWorksheetSource(xml, edits) {
     nextAttrs = nextAttrs.replace(attrPattern("sheet"), (_m, lead, q) => {
       return `${lead}${q}${escapeXmlAttr(nextSheet)}${q}`;
     });
-  return xml.replace(whole, `<${tag}${nextAttrs}${close}>`);
+  return xml.replace(whole, `<${tag}${nextAttrs}${close2}>`);
 }
 function rootName(xml) {
   const match2 = /<(?![?!])(?:[A-Za-z][\w.-]*:)?([A-Za-z][\w.-]*)/.exec(xml);
@@ -28576,7 +28585,7 @@ function writeMetadataPart(writer, rels, bookPart, plan, dynamicArraysUsed, sour
 }
 
 // xlsx/write/style-xml.ts
-var argb = (rgb2) => (rgb2.length === 6 ? `FF${rgb2}` : rgb2).toUpperCase();
+var argb = (rgb3) => (rgb3.length === 6 ? `FF${rgb3}` : rgb3).toUpperCase();
 function colorXml(color2, name = "color") {
   if (!color2) return "";
   if (color2.rgb) return el3(name, { rgb: argb(color2.rgb), tint: color2.tint });
@@ -31981,10 +31990,10 @@ function parseCssColor(text2) {
     return {
       rgb: (hex.length === 3 ? [...hex].map((ch) => ch + ch).join("") : hex).toUpperCase()
     };
-  const rgb2 = /^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/.exec(value);
-  if (rgb2)
+  const rgb3 = /^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/.exec(value);
+  if (rgb3)
     return {
-      rgb: rgb2.slice(1, 4).map((n) => Math.min(255, Number(n)).toString(16).padStart(2, "0")).join("").toUpperCase()
+      rgb: rgb3.slice(1, 4).map((n) => Math.min(255, Number(n)).toString(16).padStart(2, "0")).join("").toUpperCase()
     };
   const named3 = NAMED_COLORS2[value];
   return named3 ? { rgb: named3 } : void 0;
@@ -32069,10 +32078,10 @@ function removeComments(text2) {
   let from = 0;
   for (; ; ) {
     const open = text2.indexOf("<!--", from);
-    const close = open < 0 ? -1 : text2.indexOf("-->", open + 4);
-    if (close < 0) return out + text2.slice(from);
+    const close2 = open < 0 ? -1 : text2.indexOf("-->", open + 4);
+    if (close2 < 0) return out + text2.slice(from);
     out += text2.slice(from, open);
-    from = close + 3;
+    from = close2 + 3;
   }
 }
 function removeTags(text2) {
@@ -32210,12 +32219,12 @@ function parseTsv(text2) {
   while (i2 < body.length) {
     const ch = body[i2] ?? "";
     if (atFieldStart && ch === '"') {
-      const close = findClosingQuote(body, i2 + 1);
-      if (close >= 0) {
-        const next = body[close + 1];
+      const close2 = findClosingQuote(body, i2 + 1);
+      if (close2 >= 0) {
+        const next = body[close2 + 1];
         if (next === void 0 || next === "	" || next === "\n") {
-          field = body.slice(i2 + 1, close).replace(/""/g, '"');
-          i2 = close + 1;
+          field = body.slice(i2 + 1, close2).replace(/""/g, '"');
+          i2 = close2 + 1;
           atFieldStart = false;
           continue;
         }
@@ -41175,20 +41184,20 @@ function drawingPaint(node, colors, placeholder, depth = 0) {
     (transform7) => !SUPPORTED_TRANSFORMS.has(transform7.name) || (integer3(transform7.value) ?? 100001) > 1e5
   ))
     return void 0;
-  let rgb2;
+  let rgb3;
   let inherited;
-  if (color2.kind === "srgb") rgb2 = color2.value;
-  else if (color2.kind === "system") rgb2 = color2.fallback;
+  if (color2.kind === "srgb") rgb3 = color2.value;
+  else if (color2.kind === "system") rgb3 = color2.fallback;
   else if (color2.kind === "scheme") {
-    if (color2.value === "phClr") rgb2 = placeholder;
+    if (color2.value === "phClr") rgb3 = placeholder;
     else {
       inherited = drawingPaint(colors.get(color2.value), colors, placeholder, depth + 1);
-      rgb2 = inherited?.color;
+      rgb3 = inherited?.color;
     }
   }
-  if (!rgb2 || !/^#?[\da-f]{6}$/i.test(rgb2)) return void 0;
+  if (!rgb3 || !/^#?[\da-f]{6}$/i.test(rgb3)) return void 0;
   const resolved = resolveDrawingColor(
-    { kind: "srgb", value: rgb2.replace(/^#/, ""), transforms },
+    { kind: "srgb", value: rgb3.replace(/^#/, ""), transforms },
     void 0,
     { }
   );
@@ -41986,13 +41995,7 @@ function lineCap(cells3, resources, report) {
   }
   const value = number(cells3, "LineCap", NaN, report);
   if (value === 0) return "round";
-  if (value === 1 || value === 2) {
-    report(
-      "inferred-line-cap",
-      "Legacy square/extended cap geometry uses an inferred compatibility mapping."
-    );
-    return value === 1 ? "butt" : "square";
-  }
+  if (value === 1 || value === 2) return value === 1 ? "butt" : "square";
   if (Number.isFinite(value))
     report("invalid-line-cap", "The cached line cap is outside the supported enumeration.");
   return void 0;
@@ -42000,13 +42003,12 @@ function lineCap(cells3, resources, report) {
 
 // visio/line-pattern.ts
 function builtinDash(pattern) {
-  if (pattern === 23) return [2, 2];
+  if (pattern === 23) return [2, 1];
   const band = Math.floor((pattern - 2) / 7);
   const motif = (pattern - 2) % 7;
-  const dash = [6, 3, 11][band];
-  const gap = [3, 2, 5][band];
-  const long = [14, 7, 27][band];
-  const longGap = [2, 2, 5][band];
+  const dash = [8, 4, 16][band];
+  const gap = [4, 2, 8][band];
+  const long = [20, 10, 40][band];
   const lengths = [
     [dash],
     [1],
@@ -42016,9 +42018,9 @@ function builtinDash(pattern) {
     [long, dash],
     [long, dash, dash]
   ][motif];
-  return lengths.flatMap((length) => [length, motif >= 5 ? longGap : gap]);
+  return lengths.flatMap((length) => [length, gap]);
 }
-function linePattern(cells3, report) {
+function linePattern(cells3, report, cap = "round") {
   const raw2 = cells3.get("LinePattern")?.value;
   if (raw2 === "Themed") {
     report(
@@ -42033,11 +42035,14 @@ function linePattern(cells3, report) {
   }
   const pattern = number(cells3, "LinePattern", 1, report);
   if (Number.isInteger(pattern) && pattern >= 2 && pattern <= 23) {
-    report(
-      "inferred-line-pattern",
-      "Built-in line-pattern spacing uses inferred stroke-width ratios, not verified native spacing."
+    const lineDash = builtinDash(pattern).map(
+      (value, index2) => cap === "butt" ? value : value + (index2 % 2 ? 1 : -1)
     );
-    return { linePattern: pattern, lineDash: builtinDash(pattern) };
+    return {
+      linePattern: pattern,
+      lineDash,
+      ...cap === "square" && lineDash.includes(0) ? { lineDashDotLength: 0.01 / 72 } : {}
+    };
   }
   if (pattern === 254)
     report(
@@ -42054,6 +42059,25 @@ function linePattern(cells3, report) {
   return { linePattern: pattern };
 }
 
+// visio/source-paint.ts
+function sourcePaint(cells3, resolveColor2) {
+  const opacity2 = (name) => {
+    if (cells3.get(name)?.error) return void 0;
+    const cached3 = number(cells3, name, cells3.has(name) ? NaN : 0);
+    return Number.isFinite(cached3) && cached3 >= 0 && cached3 <= 1 ? 1 - cached3 : void 0;
+  };
+  const foregroundOpacity = opacity2("FillForegndTrans"), backgroundOpacity = opacity2("FillBkgndTrans"), lineColorOpacity = opacity2("LineColorTrans");
+  const pattern = cells3.get("FillPattern")?.error ? NaN : number(cells3, "FillPattern", cells3.has("FillPattern") ? NaN : 1);
+  const backgroundColor = cells3.get("FillBkgnd")?.error ? "" : resolveColor2("FillBkgnd", cells3.has("FillBkgnd") ? "" : "#ffffff");
+  return {
+    ...Number.isInteger(pattern) && pattern >= 0 && pattern <= 65535 ? { fillPatternIndex: pattern } : {},
+    ...foregroundOpacity === void 0 ? {} : { fillForegroundOpacity: foregroundOpacity },
+    ...backgroundColor ? { fillBackgroundColor: backgroundColor } : {},
+    ...backgroundOpacity === void 0 ? {} : { fillBackgroundOpacity: backgroundOpacity },
+    ...lineColorOpacity === void 0 ? {} : { lineColorOpacity }
+  };
+}
+
 // visio/text-background.ts
 function textBackground(cells3, resources, report) {
   const raw2 = cells3.get("TextBkgnd")?.value;
@@ -42134,6 +42158,15 @@ function textParagraphs(text2, markers, sheet, fontFamily, fontSize, resources,
   return paragraphs;
 }
 
+// visio/plain-text.ts
+function encodeVisioPlainText(text2) {
+  return text2 ? `${text2}
+` : "";
+}
+function decodeVisioPlainText(text2) {
+  return text2.endsWith("\n") ? text2.slice(0, -1) : text2;
+}
+
 // visio/nurbs-flatten.ts
 var CURVE_TOLERANCE = 1e-4;
 var MAX_WORK = 2e6;
@@ -42854,11 +42887,13 @@ function shapeStyle(sheet, resources, report, width = number(sheet.cells, "Width
     fill: pattern === 0 ? "none" : color(cells3, "FillForegnd", "#ffffff", resources, report, cells3, !!fillGradient),
     ...fillGradient ? { fillGradient } : {},
     ...fillPattern ? { fillPattern } : {},
+    ...sourcePaint(cells3, (name, fallback) => color(cells3, name, fallback, resources, () => {
+    })),
     lineColor: color(cells3, "LineColor", "#000000", resources, report),
     ...lineGradient ? { lineGradient } : {},
     lineWidth: themeLineWeight(cells3, resources, report) ?? Math.max(0, number(cells3, "LineWeight", 0.01, report)),
     ...cap === void 0 ? {} : { lineCap: cap },
-    ...themeSolidLinePattern(cells3, resources) ?? linePattern(cells3, report),
+    ...themeSolidLinePattern(cells3, resources) ?? linePattern(cells3, report, cap),
     // Saved and legacy stop transparencies already supply the fill opacity.
     fillOpacity: savedGradient || legacyGradient || fillPattern ? 1 : opacity(number(cells3, "FillForegndTrans", 0, report)),
     lineOpacity: lineGradient ? 1 : opacity(number(cells3, "LineColorTrans", 0, report)),
@@ -42882,7 +42917,8 @@ function runStyle(cells3, resources, report, themeCells) {
     ...transparency > 0 ? { opacity: 1 - Math.round(transparency * 255) / 255 } : {},
     bold: !!(bits & 1),
     italic: !!(bits & 2),
-    underline: !!(bits & 4)
+    underline: !!(bits & 4),
+    strikethrough: number(cells3, "Strikethru", 0, report) !== 0
   };
 }
 function shapeText(sheet, node, width, height, resources, report, consume, consumeParagraph) {
@@ -42892,8 +42928,9 @@ function shapeText(sheet, node, width, height, resources, report, consume, consu
   let currentCells = defaultCells;
   const runs = [];
   const paragraphMarkers = [];
-  let textOffset = 0;
-  const append = (text2) => {
+  let textOffset = 0, terminalDirectText = false;
+  const append = (text2, direct = false) => {
+    terminalDirectText = direct;
     if (text2) {
       consume(text2.length);
       runs.push({ text: text2, ...runStyle(currentCells, resources, report, cells3) });
@@ -42902,8 +42939,9 @@ function shapeText(sheet, node, width, height, resources, report, consume, consu
   };
   if (node && !number(cells3, "HideText", 0, report)) {
     for (const part of Array.from(node.childNodes)) {
-      if (part.nodeType === 3 || part.nodeType === 4) append(part.nodeValue ?? "");
-      else if (part.nodeType === 1) {
+      if (part.nodeType === 3 || part.nodeType === 4) {
+        if (part.nodeValue) append(part.nodeValue, true);
+      } else if (part.nodeType === 1) {
         const element2 = part;
         if (element2.localName === "cp")
           currentCells = characters.get(element2.getAttribute("IX") ?? "0") ?? defaultCells;
@@ -42924,10 +42962,10 @@ function shapeText(sheet, node, width, height, resources, report, consume, consu
   const alignment = number(paragraph2, "HorzAlign", 1, report);
   const textWidth = Math.max(0, number(cells3, "TxtWidth", width, report)), textHeight = Math.max(0, number(cells3, "TxtHeight", height, report));
   const vertical = number(cells3, "VerticalAlign", 1, report);
-  const plainText = runs.map((r) => r.text).join("");
+  const storedText = runs.map((r) => r.text).join("");
   const defaultRun = runStyle(defaultCells, resources, report, cells3);
   const paragraphs = textParagraphs(
-    plainText,
+    storedText,
     paragraphMarkers,
     sheet,
     defaultRun.fontFamily,
@@ -42937,13 +42975,16 @@ function shapeText(sheet, node, width, height, resources, report, consume, consu
     runs,
     consumeParagraph
   );
+  const lastRun = runs.at(-1);
+  if (terminalDirectText && lastRun) lastRun.text = decodeVisioPlainText(lastRun.text);
+  const plainText = runs.map((run2) => run2.text).join("");
   return {
     plainText,
     ...textBackground(cells3, resources, report),
     paragraphs,
     runs,
     ...runStyle(defaultCells, resources, report, cells3),
-    horizontalAlign: alignment === 1 ? "center" : alignment === 2 ? "right" : "left",
+    horizontalAlign: alignment === 1 ? "center" : alignment === 2 ? "right" : alignment === 3 ? "justify" : "left",
     verticalAlign: vertical === 0 ? "top" : vertical === 2 ? "bottom" : "middle",
     width: textWidth,
     height: textHeight,
@@ -43384,6 +43425,7 @@ var LINE_PROPERTIES = [
   "LineCap",
   "LinePattern",
   "LineColorTrans",
+  "LineGradientEnabled",
   "BeginArrow",
   "EndArrow",
   "BeginArrowSize",
@@ -43955,12 +43997,26 @@ async function parseVsdx(input, options = {}) {
   };
   for (const color2 of children3(child5(documentRoot, "Colors"), "ColorEntry"))
     resources.colors.set(attribute3(color2, "IX") ?? "", attribute3(color2, "RGB") ?? "");
-  children3(child5(documentRoot, "FaceNames"), "FaceName").forEach(
-    (font2, index2) => resources.fonts.set(
+  const faceNames = children3(child5(documentRoot, "FaceNames"), "FaceName");
+  if (faceNames.length > 1e4)
+    throw new VisioPackageError(
+      "METADATA_LIMIT",
+      "Document font count exceeds its metadata limit."
+    );
+  let fontCharacters = 0;
+  faceNames.forEach((font2, index2) => {
+    checkTime();
+    fontCharacters += (attribute3(font2, "Name") ?? attribute3(font2, "NameU") ?? "Arial").length;
+    if (fontCharacters > 1e6)
+      throw new VisioPackageError(
+        "METADATA_LIMIT",
+        "Document fonts exceed aggregate metadata limits."
+      );
+    resources.fonts.set(
       metadata(attribute3(font2, "ID") ?? String(index2), 256, "Font ID"),
       metadata(attribute3(font2, "Name") ?? attribute3(font2, "NameU") ?? "Arial", 1024, "Font name")
-    )
-  );
+    );
+  });
   const styles = /* @__PURE__ */ new Map();
   for (const style2 of children3(child5(documentRoot, "StyleSheets"), "StyleSheet"))
     styles.set(metadata(attribute3(style2, "ID") ?? "", 256, "Style ID"), {
@@ -44127,7 +44183,12 @@ async function parseVsdx(input, options = {}) {
     "ShapeSheet formulas, automatic connector routing, and external data are not evaluated; saved cached values and supported theme records are used.",
     { severity: "info" }
   );
-  return { format: "vsdx", pages, diagnostics: diagnosticState.finish() };
+  return {
+    format: "vsdx",
+    pages,
+    diagnostics: diagnosticState.finish(),
+    fontFamilies: [...new Set(resources.fonts.values())]
+  };
 }
 
 // automation/visio.ts
@@ -44282,203 +44343,12 @@ function writeEditedPackage(parts, maxBytes, deadline, check3) {
   });
 }
 
-// visio/edit-text.ts
-function replacePlainText(root, shapeId, text2, check3) {
-  const shapeChildren = (parent) => {
-    const containers = children3(parent, "Shapes");
-    if (containers.length > 1)
-      fail2("INVALID_SHAPE_ID", "Duplicate Shapes containers are ambiguous.");
-    return children3(containers[0], "Shape");
-  };
-  const shapes = /* @__PURE__ */ new Map();
-  const pending2 = shapeChildren(root).map((node2) => ({
-    node: node2,
-    inherited: false,
-    deleted: false
-  }));
-  while (pending2.length) {
-    check3();
-    const item = pending2.pop();
-    const id = attribute3(item.node, "ID");
-    if (!id || shapes.has(id))
-      fail2("INVALID_SHAPE_ID", "Local shape IDs must be present and unique.");
-    const inherited = item.inherited || item.node.hasAttribute("Master") || item.node.hasAttribute("MasterShape");
-    const deleted = item.deleted || ["1", "true"].includes(attribute3(item.node, "Del") ?? "");
-    shapes.set(id, { node: item.node, inherited, deleted });
-    for (const node2 of shapeChildren(item.node)) pending2.push({ node: node2, inherited, deleted });
-  }
-  const target = shapes.get(shapeId);
-  if (!target) fail2("EDIT_TARGET_NOT_FOUND", "Local shape does not exist.");
-  if (target.inherited || target.deleted)
-    fail2("UNSUPPORTED_TEXT_EDIT", "Master-linked or deleted shapes cannot be edited.");
-  const texts = children3(target.node, "Text");
-  if (texts.length !== 1)
-    fail2("UNSUPPORTED_TEXT_EDIT", "Editing requires one existing local Text element.");
-  const node = texts[0];
-  if (Array.from(node.childNodes).some((item) => item.nodeType !== 3 && item.nodeType !== 4))
-    fail2("UNSUPPORTED_TEXT_EDIT", "Rich text, fields and unknown text markup cannot be edited.");
-  if (children3(target.node, "Section").some((section) => attribute3(section, "N") === "Field"))
-    fail2("UNSUPPORTED_TEXT_EDIT", "Shapes with text fields cannot be edited.");
-  if (node.textContent === text2) return false;
-  while (node.firstChild) node.removeChild(node.firstChild);
-  node.appendChild(node.ownerDocument.createTextNode(text2));
-  return true;
-}
-function serializeEditedXml(root, limits, check3) {
-  check3();
-  const pending2 = [root.ownerDocument];
-  while (pending2.length) {
-    check3();
-    const node = pending2.pop();
-    if ((node.nodeType === 3 || node.nodeType === 4) && node.nodeValue?.includes("\r"))
-      fail2("UNSUPPORTED_XML_EDIT", "Carriage-return text cannot be preserved by this writer.");
-    if (node.nodeType === 1) {
-      for (const attr3 of Array.from(node.attributes))
-        if (/[\t\r\n]/.test(attr3.value))
-          fail2("UNSUPPORTED_XML_EDIT", "Attribute whitespace cannot be preserved by this writer.");
-    }
-    for (const child6 of Array.from(node.childNodes)) pending2.push(child6);
-  }
-  let xml = buildXml(root.ownerDocument);
-  xml = xml.replace(
-    /^<\?xml\s[^?]*\?>/,
-    (declaration) => declaration.replace(/encoding\s*=\s*(['"])[^'"]*\1/, 'encoding="UTF-8"')
-  );
-  const nodes = inspectXml(xml, limits, check3);
-  inspectNamespaces(root, check3);
-  const bytes = new TextEncoder().encode(xml);
-  if (bytes.length > limits.maxEntryBytes)
-    fail2("LIMIT_ENTRY", "Edited XML part exceeds byte limit.");
-  return { bytes, nodes };
-}
-
-// visio/edit-commands.ts
-var isVisioPageEdit = (edit) => edit.type === "insert-page" || edit.type === "reorder-page" || edit.type === "rename-page" || edit.type === "delete-page";
-function geometryChangedCells(edit) {
-  if (edit.type === "create-line")
-    return [
-      "BeginX",
-      "BeginY",
-      "EndX",
-      "EndY",
-      "PinX",
-      "PinY",
-      "Width",
-      "Height",
-      "Angle",
-      "LocPinX",
-      "LocPinY"
-    ];
-  if (edit.type === "delete-shape") return [];
-  if (edit.type === "move-line-endpoint") {
-    const prefix = edit.endpoint === "begin" ? "Begin" : "End";
-    return [`${prefix}X`, `${prefix}Y`];
-  }
-  if (edit.type === "move-shape") return ["PinX", "PinY"];
-  if (edit.type === "resize-shape") return ["Width", "Height"];
-  if (edit.type === "rotate-shape") return ["Angle"];
-  if (edit.type === "flip-shape") return ["Angle", edit.axis === "horizontal" ? "FlipX" : "FlipY"];
-  return ["PinX", "PinY", "Width", "Height"];
+// visio/cell-formula.ts
+function executableCellFormula(source2) {
+  return !source2 || source2 === "No Formula" || source2 === "Inh" ? void 0 : source2;
 }
-function snapshotVisioEdits(edits, maxEdits, maxText) {
-  if (!Array.isArray(edits) || edits.length > maxEdits)
-    fail2("LIMIT_EDITS", "Edit command count exceeds limit.");
-  let textLength = 0;
-  const text2 = (value) => {
-    if (typeof value !== "string") fail2("INVALID_EDIT", "Edit text must be a string.");
-    textLength += value.length;
-    if (textLength > maxText) fail2("LIMIT_EDIT_TEXT", "Replacement text exceeds aggregate limit.");
-    if (/[\u0000-\u0008\u000b\u000c\u000d\u000e-\u001f\ufffe\uffff]|[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/u.test(
-      value
-    ))
-      fail2("INVALID_EDIT_TEXT", "Replacement text contains invalid XML characters.");
-    return value;
-  };
-  const numeric5 = (value, dimension2 = false, allowZero = false) => {
-    if (typeof value !== "number" || !Number.isFinite(value) || Math.abs(value) > 1e6 || dimension2 && (value < 0 || !allowZero && value === 0))
-      fail2(
-        "INVALID_EDIT",
-        "Geometry requires finite drawing inches within limits and positive dimensions."
-      );
-    return value;
-  };
-  return Array.from(edits, (edit) => {
-    if (!edit || typeof edit.pageId !== "string" || !edit.pageId || edit.pageId.length > 256)
-      fail2("INVALID_EDIT", "Invalid edit target.");
-    if (edit.type === "delete-page") return { type: edit.type, pageId: edit.pageId };
-    if (edit.type === "reorder-page") {
-      if (!Number.isSafeInteger(edit.index) || edit.index < 0 || edit.index > 1e6)
-        fail2("INVALID_EDIT", "Page order requires a bounded zero-based integer index.");
-      return { type: edit.type, pageId: edit.pageId, index: edit.index };
-    }
-    if (edit.type === "insert-page") {
-      const name = text2(edit.name);
-      if (!/^(0|[1-9]\d{0,9})$/.test(edit.pageId) || Number(edit.pageId) > 4294967295 || typeof edit.afterPageId !== "string" || !edit.afterPageId || edit.afterPageId.length > 256 || !name.trim() || name.length > 256 || /[\t\n]/.test(name))
-        fail2("INVALID_EDIT", "Invalid new page ID, name or insertion target.");
-      return { type: edit.type, pageId: edit.pageId, afterPageId: edit.afterPageId, name };
-    }
-    if (edit.type === "rename-page") {
-      const name = text2(edit.name);
-      if (!name.trim() || name.length > 255 || /[\t\n]/.test(name))
-        fail2("INVALID_EDIT", "Invalid page name.");
-      return { type: edit.type, pageId: edit.pageId, name };
-    }
-    if (typeof edit.shapeId !== "string" || !edit.shapeId || edit.shapeId.length > 256)
-      fail2("INVALID_EDIT", "Invalid edit shape target.");
-    const target = { pageId: edit.pageId, shapeId: edit.shapeId };
-    if (edit.type === "replace-plain-text")
-      return { ...target, type: edit.type, text: text2(edit.text) };
-    if (!/^[1-9]\d{0,9}$/.test(edit.shapeId) || Number(edit.shapeId) > 4294967295)
-      fail2("INVALID_EDIT", "Geometry shape IDs must be canonical positive unsigned integers.");
-    switch (edit.type) {
-      case "create-line": {
-        const beginX = numeric5(edit.beginX), beginY = numeric5(edit.beginY);
-        const endX = numeric5(edit.endX), endY = numeric5(edit.endY);
-        numeric5(Math.hypot(endX - beginX, endY - beginY), true);
-        return { ...target, type: edit.type, beginX, beginY, endX, endY };
-      }
-      case "create-rectangle":
-      case "create-ellipse":
-        return {
-          ...target,
-          type: edit.type,
-          x: numeric5(edit.x),
-          y: numeric5(edit.y),
-          width: numeric5(edit.width, true),
-          height: numeric5(edit.height, true),
-          ...edit.text === void 0 ? {} : { text: text2(edit.text) }
-        };
-      case "rotate-shape":
-        return { ...target, type: edit.type, angle: numeric5(edit.angle) };
-      case "flip-shape":
-        if (edit.axis !== "horizontal" && edit.axis !== "vertical")
-          fail2("INVALID_EDIT", "Invalid flip axis.");
-        return { ...target, type: edit.type, axis: edit.axis };
-      case "move-shape":
-        return { ...target, type: edit.type, x: numeric5(edit.x), y: numeric5(edit.y) };
-      case "move-line-endpoint":
-        if (edit.endpoint !== "begin" && edit.endpoint !== "end")
-          fail2("INVALID_EDIT", "A line endpoint must be begin or end.");
-        return {
-          ...target,
-          type: edit.type,
-          endpoint: edit.endpoint,
-          x: numeric5(edit.x),
-          y: numeric5(edit.y)
-        };
-      case "resize-shape":
-        return {
-          ...target,
-          type: edit.type,
-          width: numeric5(edit.width, true),
-          height: numeric5(edit.height, true, true)
-        };
-      case "delete-shape":
-        return { ...target, type: edit.type };
-      default:
-        return fail2("INVALID_EDIT", "Unsupported edit command.");
-    }
-  });
+function inertDoubleClickFormula(cell, source2) {
+  return cell === "EventDblClick" && /^\s*=?\s*(OPENTEXTWIN|DEFAULTEVENT)\(\s*\)\s*$/i.test(source2);
 }
 
 // visio/formula-theme.ts
@@ -44564,11 +44434,11 @@ function evaluateNumericFormulaFunction(name, args) {
     if (args.length < min || args.length > max)
       return formulaFailure("arity", `Invalid ${name} argument count`);
   };
-  const scalar3 = (value) => ({ value, unit: "scalar" });
+  const scalar4 = (value) => ({ value, unit: "scalar" });
   if (name === "AND" || name === "OR" || name === "NOT") {
     arity(1, name === "NOT" ? 1 : 1024);
     const values2 = args.map((arg) => finiteFormulaValue(arg).value !== 0);
-    return scalar3(
+    return scalar4(
       Number(
         name === "AND" ? values2.every(Boolean) : name === "OR" ? values2.some(Boolean) : !values2[0]
       )
@@ -44582,7 +44452,7 @@ function evaluateNumericFormulaFunction(name, args) {
         return formulaFailure("value", `${name} requires an integer from 0 to 65535`);
       return arg.value;
     });
-    return scalar3(
+    return scalar4(
       name === "BITAND" ? values2[0] & values2[1] : name === "BITOR" ? values2[0] | values2[1] : values2[0] ^ values2[1]
     );
   }
@@ -45011,6 +44881,115 @@ function parseVisioFormula(source2, limits = {}) {
   return ast;
 }
 
+// visio/edit-formatting-rows.ts
+var delegatedSources = /* @__PURE__ */ new WeakMap();
+function delegatedFormattingCell(cell) {
+  const seen = /* @__PURE__ */ new Set();
+  while (cell && attribute3(cell, "F") === "Inh") {
+    const ancestor = delegatedSources.get(cell);
+    if (!ancestor || seen.has(cell) || seen.size >= 64 || cell.hasAttribute("E"))
+      fail2("EDIT_PROTECTED_CELL", "Inherited formatting has no proven source.");
+    seen.add(cell);
+    const current = attribute3(cell, "V"), previous = attribute3(ancestor, "V");
+    if (current !== previous || attribute3(cell, "U") !== attribute3(ancestor, "U")) {
+      let agrees = false;
+      try {
+        const a2 = visioFormulaCachedValue(current ?? "", attribute3(cell, "U"));
+        const b = visioFormulaCachedValue(previous ?? "", attribute3(ancestor, "U"));
+        agrees = a2.value === b.value && a2.unit === b.unit;
+      } catch {
+      }
+      if (!agrees)
+        fail2(
+          "EDIT_PROTECTED_CELL",
+          "Inherited formatting cache is stale or has incompatible units."
+        );
+    }
+    cell = ancestor;
+  }
+  return cell;
+}
+function formattingIndex(value) {
+  if (value === void 0 || !/^(0|[1-9]\d{0,9})$/.test(value) || Number(value) > 4294967295)
+    fail2("UNSUPPORTED_FORMAT_EDIT", "Formatting requires canonical unsigned row indices.");
+  return value;
+}
+function formattingRows(sheet, sectionName) {
+  const sections = children3(sheet, "Section").filter((section2) => {
+    const name = attribute3(section2, "N");
+    if (name?.toLowerCase() === sectionName.toLowerCase() && name !== sectionName)
+      fail2("UNSUPPORTED_FORMAT_EDIT", "Noncanonical formatting section names are unsupported.");
+    return name === sectionName;
+  });
+  if (sections.length > 1) fail2("UNSUPPORTED_FORMAT_EDIT", "Formatting section is ambiguous.");
+  const section = sections[0];
+  const result2 = /* @__PURE__ */ new Map();
+  if (!section) return result2;
+  if (section.hasAttribute("Del") || (attribute3(section, "IX") ?? "0") !== "0")
+    fail2("UNSUPPORTED_FORMAT_EDIT", "Formatting requires one live section with index zero.");
+  for (const row2 of children3(section, "Row")) {
+    const index2 = formattingIndex(attribute3(row2, "IX") ?? "0");
+    if (row2.hasAttribute("Del") || row2.hasAttribute("N") || row2.hasAttribute("T") || result2.has(index2))
+      fail2("UNSUPPORTED_FORMAT_EDIT", "Formatting requires unique live indexed rows.");
+    result2.set(index2, row2);
+    if (result2.size > 1e4) fail2("UNSUPPORTED_FORMAT_EDIT", "Formatting row limit exceeded.");
+  }
+  return result2;
+}
+function formattingRow(sheet, sectionName, index2 = "0") {
+  return formattingRows(sheet, sectionName).get(index2);
+}
+function mergeFormattingRows(base, sheet, sectionName, cells3) {
+  const result2 = new Map(base);
+  for (const [index2, row2] of formattingRows(sheet, sectionName)) {
+    const merged = new Map(base.get(index2) ?? base.get("0"));
+    for (const [name, cell] of cells3(row2)) {
+      if (attribute3(cell, "F") === "Inh" && !cell.hasAttribute("V") && !cell.hasAttribute("E"))
+        continue;
+      const ancestor = merged.get(name);
+      const inheritedUnit = attribute3(ancestor, "U");
+      let effective = cell;
+      if (!cell.hasAttribute("U") && inheritedUnit !== void 0) {
+        effective = cell.cloneNode(true);
+        effective.setAttribute("U", inheritedUnit);
+      }
+      if (attribute3(cell, "F") === "Inh") delegatedSources.set(effective, ancestor);
+      merged.set(name, effective);
+    }
+    result2.set(index2, merged);
+    if (result2.size > 1e4) fail2("UNSUPPORTED_FORMAT_EDIT", "Formatting row limit exceeded.");
+  }
+  return result2;
+}
+function assertFormattingText(shape2, characters, paragraphs) {
+  const texts = children3(shape2, "Text");
+  if (texts.length !== 1)
+    fail2("UNSUPPORTED_FORMAT_EDIT", "Text formatting requires one existing local Text.");
+  let fields;
+  for (const part of Array.from(texts[0].childNodes)) {
+    if (part.nodeType === 3 || part.nodeType === 4) continue;
+    const marker4 = part;
+    if (part.nodeType !== 1 || marker4.namespaceURI !== shape2.namespaceURI || !["cp", "pp", "tp", "fld"].includes(marker4.localName))
+      fail2("UNSUPPORTED_FORMAT_EDIT", "Unknown text markup cannot be formatted.");
+    const index2 = formattingIndex(attribute3(marker4, "IX"));
+    if (marker4.localName === "fld") {
+      fields ??= formattingRows(shape2, "Field");
+      if (!fields.has(index2) || Array.from(marker4.childNodes).some((node) => ![3, 4].includes(node.nodeType)))
+        fail2(
+          "UNSUPPORTED_FORMAT_EDIT",
+          "Text fields require a live local field row and plain cached text."
+        );
+      continue;
+    }
+    const rows = marker4.localName === "cp" ? characters : marker4.localName === "pp" ? paragraphs : void 0;
+    if (marker4.childNodes.length || index2 !== "0" && rows && !rows.has(index2))
+      fail2(
+        "UNSUPPORTED_FORMAT_EDIT",
+        "Formatting markers require existing rows and no nested markup."
+      );
+  }
+}
+
 // visio/edit-geometry-cells.ts
 var cells = (shape2) => new Map(children3(shape2, "Cell").map((node) => [attribute3(node, "N") ?? "", node]));
 function numeric4(node, fallback) {
@@ -45083,14 +45062,6 @@ function assertEllipseResizeRow(shape2, row2) {
   }
 }
 
-// visio/cell-formula.ts
-function executableCellFormula(source2) {
-  return !source2 || source2 === "No Formula" || source2 === "Inh" ? void 0 : source2;
-}
-function inertDoubleClickFormula(cell, source2) {
-  return cell === "EventDblClick" && /^\s*=?\s*(OPENTEXTWIN|DEFAULTEVENT)\(\s*\)\s*$/i.test(source2);
-}
-
 // visio/edit-recalculate-index.ts
 var key = (cell) => JSON.stringify([cell.pageId, cell.shapeId, cell.cell.toLowerCase()]);
 function bound(value, fallback) {
@@ -45342,26 +45313,27 @@ function recalculateVisioCells(roots, changed, options = {}) {
   }
   return [...pages];
 }
-function assertVisioShapeUnreferenced(roots, pageId, shapeId, options = {}) {
+function assertVisioShapesUnreferenced(roots, removed, options = {}) {
   const cells3 = indexCells(roots, options);
   for (const cell of cells3.values()) {
-    if (cell.pageId !== pageId || cell.shapeId === shapeId) continue;
+    options.check?.();
+    if (removed.get(cell.pageId)?.has(cell.shapeId)) continue;
     if (cell.dependencies.some((id) => {
       const parts = JSON.parse(id);
-      return parts[0] === pageId && parts[1] === shapeId;
+      return removed.get(parts[0])?.has(parts[1]) ?? false;
     }))
       fail2("EDIT_REFERENCED_DELETE", "Shape is referenced by a ShapeSheet formula.");
   }
-  const root = roots.get(pageId);
-  if (root)
-    for (const connections2 of children3(root, "Connects"))
+  for (const [pageId, ids] of removed)
+    for (const connections2 of children3(roots.get(pageId), "Connects"))
       for (const connection of children3(connections2, "Connect")) {
-        if (["FromSheet", "ToSheet"].some((name) => attribute3(connection, name) === shapeId))
+        options.check?.();
+        if (["FromSheet", "ToSheet"].some((name) => ids.has(attribute3(connection, name) ?? "")))
           fail2("EDIT_REFERENCED_DELETE", "Shape participates in a Connect record.");
       }
 }
-function visioCellDependsOn(roots, source2, targets, options = {}) {
-  return createVisioDependencyQuery(roots, options)(source2, targets);
+function assertVisioShapeUnreferenced(roots, pageId, shapeId, options = {}) {
+  assertVisioShapesUnreferenced(roots, /* @__PURE__ */ new Map([[pageId, /* @__PURE__ */ new Set([shapeId])]]), options);
 }
 function createVisioDependencyQuery(roots, options = {}) {
   const cells3 = indexCells(roots, options);
@@ -45554,6 +45526,7 @@ function protectedShape(shape2, document, masterMovePins = /* @__PURE__ */ new S
 }
 function resizeGeometry(shape2, roots, edit, check3, lineEditShapes = /* @__PURE__ */ new Set()) {
   const sections = children3(shape2, "Section").filter((node) => attribute3(node, "N") === "Geometry");
+  let depends;
   if (!sections.length)
     fail2("UNSUPPORTED_GEOMETRY_EDIT", "Resizing requires explicit supported local geometry.");
   for (const section of sections) {
@@ -45583,15 +45556,14 @@ function resizeGeometry(shape2, roots, edit, check3, lineEditShapes = /* @__PURE
         const analysis = analyzeVisioFormula(formula);
         if (!analysis.references.length && numeric4(node) === 0) continue;
         const cell = `Geometry${Number(attribute3(section, "IX") ?? "0") + 1}.${attribute3(node, "N")}${attribute3(row2, "IX")}`;
-        if (!visioCellDependsOn(
-          roots,
+        depends ??= createVisioDependencyQuery(roots, { check: check3, lineEditShapes });
+        if (!depends(
           { pageId: edit.pageId, shapeId: edit.shapeId, cell },
           ["Width", "Height"].map((cell2) => ({
             pageId: edit.pageId,
             shapeId: edit.shapeId,
             cell: cell2
-          })),
-          { check: check3, lineEditShapes }
+          }))
         ))
           fail2(
             "UNSUPPORTED_GEOMETRY_EDIT",
@@ -45609,6 +45581,704 @@ function assertLengthTransformCells(local) {
   }
 }
 
+// visio/edit-formatting-cell-admission.ts
+function assertEditableFormattingCell(cell) {
+  const source2 = executableCellFormula(attribute3(cell, "F"));
+  const ast = source2 ? parseVisioFormula(source2) : void 0;
+  const themeLiteral = (node) => {
+    if (node.kind === "string" || node.kind === "number") return true;
+    if (node.kind !== "call" || !node.args.every(themeLiteral)) return false;
+    if (node.name === "THEMEGUARD") return node.args.length <= 1;
+    if (node.name === "THEME")
+      return node.args.length === 0 || node.args.length === 1 && node.args[0]?.kind === "string";
+    if (node.name !== "THEMEVAL" || node.args.length > 2) return false;
+    const selector = node.args[0];
+    return !selector || selector.kind === "string" || selector.kind === "number" && selector.unit === "scalar" && Number.isInteger(selector.value) && selector.value >= 1 && selector.value <= 8;
+  };
+  if (ast?.kind === "call" && (ast.name === "FONT" && ast.args.length === 1 && ast.args[0]?.kind === "string" || ast.name === "RGB" && ast.args.length === 3 && ast.args.every(
+    (arg) => arg.kind === "number" && arg.unit === "scalar" && Number.isInteger(arg.value) && arg.value >= 0 && arg.value <= 255
+  ) || ["THEMEVAL", "THEME", "THEMEGUARD"].includes(ast.name) && themeLiteral(ast))) {
+    if (cell?.hasAttribute("E"))
+      fail2("EDIT_PROTECTED_CELL", "Cannot overwrite an error formatting cell.");
+    return;
+  }
+  editableCell(cell);
+  if (source2 && cell) {
+    const actual = evaluateVisioFormula(
+      source2,
+      () => fail2("EDIT_PROTECTED_CELL", "Formatting dependencies cannot be overwritten.")
+    );
+    const cache3 = visioFormulaCachedValue(attribute3(cell, "V") ?? "", attribute3(cell, "U"));
+    if (actual.value !== cache3.value || actual.unit !== cache3.unit && !(cache3.unit === "scalar" && actual.unit === "length" && !cell.hasAttribute("U")))
+      fail2("EDIT_PROTECTED_CELL", "Formatting formula cache is stale or has incompatible units.");
+  }
+}
+
+// visio/edit-style-admission.ts
+function uniqueFormattingCells(sheet) {
+  const result2 = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  for (const cell of children3(sheet, "Cell")) {
+    const name = attribute3(cell, "N");
+    if (!name || seen.has(name.toLowerCase()))
+      fail2("EDIT_AMBIGUOUS_CELL", "Formatting requires unique named cells.");
+    result2.set(name, cell);
+    seen.add(name.toLowerCase());
+  }
+  return result2;
+}
+function formattingCell(sheet, name) {
+  const cells3 = uniqueFormattingCells(sheet);
+  if (!cells3.has(name) && [...cells3.keys()].some((key2) => key2.toLowerCase() === name.toLowerCase()))
+    fail2("EDIT_AMBIGUOUS_CELL", "Noncanonical formatting cell names cannot be overridden.");
+  return cells3.get(name);
+}
+function namedCell(sheet, name) {
+  const [section, index2, cell] = name.split(".");
+  if (!cell) return formattingCell(sheet, name);
+  const row2 = formattingRow(sheet, section, index2);
+  return row2 ? formattingCell(row2, cell) : void 0;
+}
+function categoryEnabled(style2, category) {
+  const name = category === "TextStyle" ? "EnableTextProps" : category === "FillStyle" ? "EnableFillProps" : "EnableLineProps";
+  const cell = formattingCell(style2, name);
+  if (!cell) return true;
+  if (cell.hasAttribute("E") || attribute3(cell, "F") === "Inh")
+    fail2("EDIT_PROTECTED_CELL", "Style category enable state cannot be proven.");
+  const cache3 = visioFormulaCachedValue(attribute3(cell, "V") ?? "", attribute3(cell, "U"));
+  if (cache3.unit !== "scalar" || ![0, 1].includes(cache3.value))
+    fail2("EDIT_PROTECTED_CELL", "Style category enable state must be a scalar boolean.");
+  const source2 = executableCellFormula(attribute3(cell, "F"));
+  if (source2) {
+    const analysis = analyzeVisioFormula(source2);
+    if (analysis.dynamic || analysis.references.length || analysis.unsupportedFunctions.length)
+      fail2("EDIT_PROTECTED_CELL", "Style category enable formula cannot be resolved safely.");
+    const result2 = evaluateVisioFormula(
+      source2,
+      () => fail2("EDIT_PROTECTED_CELL", "Style category enable dependencies are unsupported.")
+    );
+    if (result2.unit !== "scalar" || result2.value !== cache3.value)
+      fail2("EDIT_PROTECTED_CELL", "Style category enable formula cache is stale.");
+  }
+  return cache3.value !== 0;
+}
+function formattingStyles(shape2, document, category, gate) {
+  const styles = /* @__PURE__ */ new Map();
+  for (const container of children3(document, "StyleSheets"))
+    for (const style2 of children3(container, "StyleSheet")) {
+      const id2 = attribute3(style2, "ID");
+      if (!id2 || styles.has(id2)) fail2("EDIT_PROTECTED_CELL", "Ambiguous formatting style IDs.");
+      styles.set(id2, style2);
+    }
+  const sheets = children3(document, "DocumentSheet");
+  if (sheets.length > 1) fail2("EDIT_PROTECTED_CELL", "Ambiguous document formatting defaults.");
+  let id = attribute3(shape2, category) ?? attribute3(sheets[0], category) ?? (styles.has("0") ? "0" : void 0);
+  const seen = /* @__PURE__ */ new Set();
+  const result2 = [];
+  while (id !== void 0) {
+    if (seen.has(id) || seen.size >= 64)
+      fail2("EDIT_PROTECTED_CELL", "Formatting style ancestry is cyclic or too deep.");
+    seen.add(id);
+    const style2 = styles.get(id);
+    if (!style2) fail2("EDIT_PROTECTED_CELL", "Formatting style ancestry cannot be resolved.");
+    if (gate && !categoryEnabled(style2, category)) break;
+    result2.push(style2);
+    const parent = attribute3(style2, category);
+    id = parent !== id ? parent : void 0;
+  }
+  return result2;
+}
+function effectiveFormattingRows(shape2, document, section) {
+  let result2 = /* @__PURE__ */ new Map();
+  for (const style2 of formattingStyles(shape2, document, "TextStyle", true).reverse())
+    result2 = mergeFormattingRows(result2, style2, section, uniqueFormattingCells);
+  return mergeFormattingRows(result2, shape2, section, uniqueFormattingCells);
+}
+function formattingRowContext(shape2, document, section) {
+  return {
+    source: effectiveFormattingRows(shape2, document, section),
+    local: formattingRows(shape2, section)
+  };
+}
+function effectiveShapeCell(shape2, document, name, category, rows) {
+  const [section, index2, cellName] = name.split(".");
+  const localRow = rows?.local.get(index2);
+  const local = rows ? localRow ? formattingCell(localRow, cellName) : void 0 : namedCell(shape2, name);
+  const delegatedLocal = local && attribute3(local, "F") === "Inh";
+  if (delegatedLocal && !(category === "TextStyle" && cellName && ["Character", "Paragraph"].includes(section)))
+    fail2("EDIT_PROTECTED_CELL", "Inherited formatting cells cannot be overwritten.");
+  if (local && !cellName) return local;
+  if (cellName) {
+    const sources = rows?.source ?? effectiveFormattingRows(shape2, document, section);
+    const cells3 = sources.get(index2) ?? sources.get("0");
+    if (cells3 && !cells3.has(cellName) && [...cells3.keys()].some((key2) => key2.toLowerCase() === cellName.toLowerCase()))
+      fail2("EDIT_AMBIGUOUS_CELL", "Noncanonical formatting cell names cannot be overridden.");
+    const effective = delegatedFormattingCell(cells3?.get(cellName));
+    if (delegatedLocal) {
+      if (!effective)
+        fail2(
+          "EDIT_PROTECTED_CELL",
+          "Inherited formatting cannot be overwritten without a proven ancestor."
+        );
+      if (!local.hasAttribute("V") && local.hasAttribute("U") && visioFormulaCachedValue("0", attribute3(local, "U")).unit !== visioFormulaCachedValue("0", attribute3(effective, "U")).unit)
+        fail2("EDIT_PROTECTED_CELL", "Inherited formatting has incompatible local units.");
+    }
+    return effective;
+  }
+  for (const style2 of formattingStyles(
+    shape2,
+    document,
+    category,
+    !/^(Lock|LayerMember$|DisplayLevel$)/.test(name)
+  )) {
+    const cell = namedCell(style2, name);
+    if (cell && attribute3(cell, "F") !== "Inh") return cell;
+    if (cell && (!attribute3(style2, category) || attribute3(style2, category) === attribute3(style2, "ID")))
+      fail2("EDIT_PROTECTED_CELL", "Delegated formatting has no explicit ancestor.");
+  }
+  return void 0;
+}
+function assertShapeLocks(shape2, document, locks2) {
+  const inheritedShape = shape2.cloneNode(true);
+  for (const cell of children3(inheritedShape, "Cell"))
+    if (locks2.includes(attribute3(cell, "N") ?? "")) inheritedShape.removeChild(cell);
+  for (const lock of locks2)
+    for (const [target, category] of [
+      [shape2, "LineStyle"],
+      [inheritedShape, "LineStyle"],
+      [inheritedShape, "FillStyle"],
+      [inheritedShape, "TextStyle"]
+    ]) {
+      const cell = effectiveShapeCell(target, document, lock, category);
+      if (!cell) continue;
+      if (cell.hasAttribute("E"))
+        fail2("EDIT_PROTECTED_CELL", "Formatting protection has an error.");
+      const cached3 = visioFormulaCachedValue(attribute3(cell, "V") ?? "", attribute3(cell, "U"));
+      if (cached3.unit !== "scalar" || cached3.value !== 0)
+        fail2("EDIT_PROTECTED_CELL", "Formatting protection is active or invalid.");
+      const formula = executableCellFormula(attribute3(cell, "F"));
+      if (!formula) continue;
+      const analysis = analyzeVisioFormula(formula);
+      if (analysis.dynamic || analysis.references.length || analysis.unsupportedFunctions.length)
+        fail2("EDIT_PROTECTED_CELL", "Formatting protection formula cannot be proven safe.");
+      const value = evaluateVisioFormula(
+        formula,
+        () => fail2("EDIT_PROTECTED_CELL", "Formatting lock dependency is unsupported.")
+      );
+      if (value.unit !== "scalar" || value.value !== cached3.value)
+        fail2("EDIT_PROTECTED_CELL", "Formatting protection cache is stale.");
+    }
+}
+function assertUnlayeredShape(shape2, document) {
+  for (const category of ["LineStyle", "FillStyle", "TextStyle"]) {
+    const cell = effectiveShapeCell(shape2, document, "LayerMember", category);
+    if (!cell) continue;
+    if (attribute3(cell, "V") !== "" || cell.hasAttribute("E") || executableCellFormula(attribute3(cell, "F")))
+      fail2(
+        "UNSUPPORTED_FORMAT_EDIT",
+        "Layered or unresolved layer membership is not yet supported."
+      );
+  }
+}
+
+// visio/edit-text.ts
+async function replacePlainText(root, document, shapeId, text2, check3, assertDependencies) {
+  const shapeChildren = (parent) => {
+    const containers = children3(parent, "Shapes");
+    if (containers.length > 1)
+      fail2("INVALID_SHAPE_ID", "Duplicate Shapes containers are ambiguous.");
+    return children3(containers[0], "Shape");
+  };
+  const shapes = /* @__PURE__ */ new Map();
+  const pending2 = shapeChildren(root).map((node2) => ({
+    node: node2,
+    inherited: false,
+    deleted: false
+  }));
+  while (pending2.length) {
+    check3();
+    const item = pending2.pop();
+    const id = attribute3(item.node, "ID");
+    if (!id || shapes.has(id))
+      fail2("INVALID_SHAPE_ID", "Local shape IDs must be present and unique.");
+    const inherited = item.inherited || item.node.hasAttribute("Master") || item.node.hasAttribute("MasterShape");
+    const deleted = item.deleted || ["1", "true"].includes(attribute3(item.node, "Del") ?? "");
+    shapes.set(id, { node: item.node, inherited, deleted });
+    for (const node2 of shapeChildren(item.node)) pending2.push({ node: node2, inherited, deleted });
+  }
+  const target = shapes.get(shapeId);
+  if (!target) fail2("EDIT_TARGET_NOT_FOUND", "Local shape does not exist.");
+  if (target.inherited || target.deleted)
+    fail2("UNSUPPORTED_TEXT_EDIT", "Master-linked or deleted shapes cannot be edited.");
+  assertShapeLocks(target.node, document, ["LockTextEdit"]);
+  const texts = children3(target.node, "Text");
+  if (texts.length !== 1)
+    fail2("UNSUPPORTED_TEXT_EDIT", "Editing requires one existing local Text element.");
+  const node = texts[0];
+  if (Array.from(node.childNodes).some((item) => item.nodeType !== 3 && item.nodeType !== 4))
+    fail2("UNSUPPORTED_TEXT_EDIT", "Rich text, fields and unknown text markup cannot be edited.");
+  if (children3(target.node, "Section").some((section) => attribute3(section, "N") === "Field"))
+    fail2("UNSUPPORTED_TEXT_EDIT", "Shapes with text fields cannot be edited.");
+  if (decodeVisioPlainText(node.textContent ?? "") === text2) return false;
+  await assertDependencies(target.node, node);
+  check3();
+  while (node.firstChild) node.removeChild(node.firstChild);
+  node.appendChild(node.ownerDocument.createTextNode(encodeVisioPlainText(text2)));
+  return true;
+}
+function serializeEditedXml(root, limits, check3) {
+  check3();
+  const pending2 = [root.ownerDocument];
+  while (pending2.length) {
+    check3();
+    const node = pending2.pop();
+    if ((node.nodeType === 3 || node.nodeType === 4) && node.nodeValue?.includes("\r"))
+      fail2("UNSUPPORTED_XML_EDIT", "Carriage-return text cannot be preserved by this writer.");
+    if (node.nodeType === 1) {
+      for (const attr3 of Array.from(node.attributes))
+        if (/[\t\r\n]/.test(attr3.value))
+          fail2("UNSUPPORTED_XML_EDIT", "Attribute whitespace cannot be preserved by this writer.");
+    }
+    for (const child6 of Array.from(node.childNodes)) pending2.push(child6);
+  }
+  let xml = buildXml(root.ownerDocument);
+  xml = xml.replace(
+    /^<\?xml\s[^?]*\?>/,
+    (declaration) => declaration.replace(/encoding\s*=\s*(['"])[^'"]*\1/, 'encoding="UTF-8"')
+  );
+  const nodes = inspectXml(xml, limits, check3);
+  inspectNamespaces(root, check3);
+  const bytes = new TextEncoder().encode(xml);
+  if (bytes.length > limits.maxEntryBytes)
+    fail2("LIMIT_ENTRY", "Edited XML part exceeds byte limit.");
+  return { bytes, nodes };
+}
+
+// visio/edit-formatting-scope.ts
+async function assertFormattingDependencies(pkg, pagePaths, roots, pageId, shape2, changed, check3) {
+  indexCells(roots, { check: check3 });
+  const shapeId = attribute3(shape2, "ID");
+  const changedNames = new Set([...changed.keys()].map((name) => name.toLowerCase()));
+  const canonical = (name) => name.toLowerCase().replace(/^char\.([a-z]+)$/, "character.0.$1").replace(/^para\.([a-z]+)$/, "paragraph.0.$1");
+  const replaced = new Set(changed.values());
+  const inspect2 = (root, sourcePageId) => {
+    for (const node of [root, ...Array.from(root.getElementsByTagName("*"))]) {
+      check3();
+      if (![VISIO_NS, VISIO_LEGACY_NS].includes(node.namespaceURI ?? "") || replaced.has(node))
+        continue;
+      const source2 = executableCellFormula(attribute3(node, "F"));
+      if (!source2 || inertDoubleClickFormula(attribute3(node, "N") ?? "", source2)) continue;
+      let localShapeId;
+      let parent = node;
+      while (parent?.nodeType === 1) {
+        if (parent.localName === "Shape") {
+          localShapeId = attribute3(parent, "ID");
+          break;
+        }
+        parent = parent.parentNode;
+      }
+      const analysis = analyzeVisioFormula(source2);
+      if (analysis.dynamic || analysis.references.some(
+        (ref) => changedNames.has(canonical(ref.cell)) && (sourcePageId === void 0 || sourcePageId === pageId) && (ref.shapeId === shapeId || ref.shapeId === void 0 && (localShapeId === shapeId || sourcePageId === void 0))
+      ))
+        fail2(
+          "EDIT_UNSUPPORTED_FORMAT_DEPENDENCY",
+          "Formatting has affected or unknown formula dependencies; dependent caches cannot be recalculated safely."
+        );
+    }
+  };
+  for (const [id, root] of roots) inspect2(root, id);
+  for (const path2 of pkg.paths()) {
+    if (!/^visio\/.*\.xml$/i.test(path2) || pagePaths.has(path2)) continue;
+    inspect2(await pkg.readXml(path2));
+  }
+}
+
+// visio/edit-text-scope.ts
+function replaceScopedPlainText(pkg, pagePaths, roots, document, edit, check3) {
+  return replacePlainText(
+    roots.get(edit.pageId),
+    document,
+    edit.shapeId,
+    edit.text,
+    check3,
+    (shape2, text2) => assertFormattingDependencies(
+      pkg,
+      pagePaths,
+      roots,
+      edit.pageId,
+      shape2,
+      /* @__PURE__ */ new Map([["TheText", text2]]),
+      check3
+    )
+  );
+}
+
+// visio/resize-anchor.ts
+function snapshotResizeAnchor(value) {
+  if (value === void 0) return void 0;
+  if (!value || typeof value !== "object") fail2("INVALID_EDIT", "Invalid resize anchor.");
+  const { x, y } = value;
+  if (![0, 0.5, 1].includes(x) || ![0, 0.5, 1].includes(y))
+    fail2("INVALID_EDIT", "Resize anchor coordinates must be 0, 0.5 or 1.");
+  return { x, y };
+}
+function visioAnchoredResizeGeometry(current, size, anchor) {
+  const [a2, b, c2, d, e, f6] = current.transform;
+  const determinant = a2 * d - b * c2;
+  if (![0, 0.5, 1].includes(anchor.x) || ![0, 0.5, 1].includes(anchor.y) || ![
+    current.width,
+    current.height,
+    current.pinX,
+    current.pinY,
+    ...current.transform,
+    size.width,
+    size.height,
+    anchor.x,
+    anchor.y
+  ].every(Number.isFinite) || !(current.width > 0 && current.height > 0 && size.width > 0 && size.height > 0) || Math.abs(Math.abs(determinant) - 1) > 1e-8 || Math.abs(a2 * a2 + b * b - 1) > 1e-8 || Math.abs(c2 * c2 + d * d - 1) > 1e-8 || Math.abs(a2 * c2 + b * d) > 1e-8)
+    return void 0;
+  const offsetX = current.pinX - e, offsetY = current.pinY - f6;
+  const oldX = (d * offsetX - c2 * offsetY) / determinant;
+  const oldY = (-b * offsetX + a2 * offsetY) / determinant;
+  const locPinX = oldX / current.width * size.width, locPinY = oldY / current.height * size.height;
+  const deltaX = anchor.x * (current.width - size.width) - oldX + locPinX;
+  const deltaY = anchor.y * (current.height - size.height) - oldY + locPinY;
+  const pinX = current.pinX + a2 * deltaX + c2 * deltaY, pinY = current.pinY + b * deltaX + d * deltaY;
+  const matrix3 = [
+    a2,
+    b,
+    c2,
+    d,
+    pinX - a2 * locPinX - c2 * locPinY,
+    pinY - b * locPinX - d * locPinY
+  ];
+  return [pinX, pinY, locPinX, locPinY, ...matrix3].every(Number.isFinite) ? { pinX, pinY, locPinX, locPinY, transform: matrix3 } : void 0;
+}
+
+// visio/edit-duplicate-commands.ts
+function snapshotDuplicateShapes(edit) {
+  if (!Array.isArray(edit.copies) || !edit.copies.length || edit.copies.length > 1e3)
+    fail2("INVALID_EDIT", "Duplication requires between one and 1000 shape mappings.");
+  if ([edit.offsetX, edit.offsetY].some(
+    (value) => typeof value !== "number" || !Number.isFinite(value) || Math.abs(value) > 1e6
+  ))
+    fail2("INVALID_EDIT", "Duplication offsets require bounded finite drawing inches.");
+  const sources = /* @__PURE__ */ new Set(), targets = /* @__PURE__ */ new Set();
+  const id = (value) => {
+    if (typeof value !== "string" || !/^(0|[1-9]\d{0,9})$/.test(value) || Number(value) > 4294967295)
+      fail2("INVALID_EDIT", "Duplicate shape IDs require canonical unsigned integers.");
+    return value;
+  };
+  const copies = edit.copies.map((copy2) => {
+    if (!copy2 || typeof copy2 !== "object") fail2("INVALID_EDIT", "Invalid duplicate shape mapping.");
+    const shapeId = id(copy2.shapeId), newShapeId = id(copy2.newShapeId);
+    if (sources.has(shapeId) || targets.has(newShapeId))
+      fail2("INVALID_EDIT", "Duplicate shape mappings must have unique sources and targets.");
+    sources.add(shapeId);
+    targets.add(newShapeId);
+    return { shapeId, newShapeId };
+  });
+  return {
+    type: edit.type,
+    pageId: edit.pageId,
+    copies,
+    offsetX: edit.offsetX,
+    offsetY: edit.offsetY
+  };
+}
+
+// visio/clipboard-types.ts
+var VISIO_CLIPBOARD_MAX_CHARS = 8 * 1024 * 1024;
+function clipboardId(value) {
+  if (typeof value !== "string" || !/^(0|[1-9]\d{0,9})$/.test(value) || Number(value) > 4294967295)
+    fail2("INVALID_CLIPBOARD", "Clipboard IDs require canonical unsigned integers.");
+  return value;
+}
+function snapshotVisioClipboard(value) {
+  if (!value || typeof value !== "object" || value.format !== "ooxml.visio-shapes" || value.version !== 1)
+    fail2("INVALID_CLIPBOARD", "Unsupported Visio clipboard format or version.");
+  const sourcePageId = clipboardId(value.sourcePageId), sourceDrawingScale = value.sourceDrawingScale;
+  if (!Number.isFinite(sourceDrawingScale) || sourceDrawingScale <= 0 || sourceDrawingScale > 1e6)
+    fail2("INVALID_CLIPBOARD", "Invalid clipboard drawing ratio.");
+  let characters = 0;
+  const text2 = (input) => {
+    if (typeof input !== "string" || (characters += input.length) > VISIO_CLIPBOARD_MAX_CHARS)
+      fail2("LIMIT_CLIPBOARD", "Clipboard XML exceeds bounded text limits.");
+    if (/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/.test(input))
+      fail2("INVALID_CLIPBOARD", "Clipboard XML must contain well-formed Unicode.");
+    return input;
+  };
+  const list = (input, max) => {
+    if (!Array.isArray(input) || !input.length || input.length > max)
+      fail2("INVALID_CLIPBOARD", "Invalid clipboard array length.");
+    return input;
+  };
+  const selectionIds = list(value.selectionIds, 1e3).map(clipboardId);
+  const shapes = list(value.shapes, 1e3).map((shape2) => {
+    if (!shape2 || typeof shape2 !== "object") fail2("INVALID_CLIPBOARD", "Invalid captured shape.");
+    return { shapeId: clipboardId(shape2.shapeId), xml: text2(shape2.xml) };
+  });
+  const resources = list(value.resources, 64).map((resource) => {
+    const path2 = resource?.path;
+    if (!resource || typeof resource !== "object" || typeof path2 !== "string" || path2.length > 1024 || !/^visio\/(?:document\.xml|_rels\/document\.xml\.rels|theme\/[^/]+\.(?:xml|rels)|theme\/_rels\/[^/]+\.rels)$/.test(
+      path2
+    ))
+      fail2("INVALID_CLIPBOARD", "Invalid clipboard resource path.");
+    return { path: text2(safePath(path2)), xml: text2(resource.xml) };
+  });
+  if (new Set(selectionIds).size !== selectionIds.length || new Set(shapes.map((shape2) => shape2.shapeId)).size !== shapes.length || selectionIds.length !== shapes.length || selectionIds.some((id) => !shapes.some((shape2) => shape2.shapeId === id)) || new Set(resources.map((resource) => resource.path)).size !== resources.length)
+    fail2("INVALID_CLIPBOARD", "Clipboard mappings and resources must be unique and complete.");
+  return {
+    format: "ooxml.visio-shapes",
+    version: 1,
+    sourcePageId,
+    sourceDrawingScale,
+    selectionIds,
+    shapes,
+    resources: resources.sort((a2, b) => a2.path.localeCompare(b.path)),
+    pageContext: text2(value.pageContext)
+  };
+}
+
+// visio/edit-paste-commands.ts
+function snapshotPasteShapes(edit) {
+  const clipboard = snapshotVisioClipboard(edit.clipboard);
+  const copies = snapshotDuplicateShapes({
+    type: "duplicate-shapes",
+    pageId: edit.pageId,
+    copies: edit.copies,
+    offsetX: edit.offsetX,
+    offsetY: edit.offsetY
+  });
+  if (copies.copies.length !== clipboard.shapes.length || copies.copies.some((copy2) => !clipboard.selectionIds.includes(copy2.shapeId)))
+    fail2("INVALID_CLIPBOARD", "Paste mappings must cover every captured shape exactly once.");
+  return {
+    type: "paste-shapes",
+    pageId: copies.pageId,
+    copies: copies.copies,
+    offsetX: copies.offsetX,
+    offsetY: copies.offsetY,
+    clipboard
+  };
+}
+
+// visio/edit-formatting-commands.ts
+var isVisioFormatEdit = (edit) => edit.type === "format-text" || edit.type === "format-shape";
+function snapshotFormatting(edit) {
+  const result2 = { type: edit.type, pageId: edit.pageId, shapeId: edit.shapeId };
+  const points = (value, minimum, maximum) => {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < minimum || value > maximum)
+      fail2("INVALID_EDIT", "Formatting point size is outside supported limits.");
+    return value;
+  };
+  const color2 = (value, allowNone = false) => {
+    if (typeof value !== "string" || !(allowNone && value === "none") && !/^#[0-9a-f]{6}$/i.test(value))
+      fail2("INVALID_EDIT", "Formatting colors require six hexadecimal digits.");
+    return value.toLowerCase();
+  };
+  if (edit.type === "format-text" && result2.type === "format-text") {
+    if (edit.fontSize !== void 0) result2.fontSize = points(edit.fontSize, 1, 1e3);
+    if (edit.fontColor !== void 0) result2.fontColor = color2(edit.fontColor);
+    if (edit.indentLeft !== void 0) result2.indentLeft = points(edit.indentLeft, 0, 7200);
+    if (edit.fontFamily !== void 0) {
+      if (typeof edit.fontFamily !== "string" || !edit.fontFamily.trim() || edit.fontFamily.length > 256 || /[\u0000-\u001f\u007f]/.test(edit.fontFamily))
+        fail2("INVALID_EDIT", "Invalid font family.");
+      result2.fontFamily = edit.fontFamily;
+    }
+    for (const name of ["bold", "italic", "underline", "strikethrough", "bullets"]) {
+      if (edit[name] === void 0) continue;
+      if (typeof edit[name] !== "boolean") fail2("INVALID_EDIT", "Text styles require booleans.");
+      result2[name] = edit[name];
+    }
+    if (edit.horizontalAlign !== void 0) {
+      if (!["left", "center", "right", "justify"].includes(edit.horizontalAlign))
+        fail2("INVALID_EDIT", "Invalid horizontal alignment.");
+      result2.horizontalAlign = edit.horizontalAlign;
+    }
+    if (edit.verticalAlign !== void 0) {
+      if (!["top", "middle", "bottom"].includes(edit.verticalAlign))
+        fail2("INVALID_EDIT", "Invalid vertical alignment.");
+      result2.verticalAlign = edit.verticalAlign;
+    }
+  } else if (edit.type === "format-shape" && result2.type === "format-shape") {
+    if (edit.fillColor !== void 0) result2.fillColor = color2(edit.fillColor, true);
+    if (edit.lineColor !== void 0) result2.lineColor = color2(edit.lineColor);
+    if (edit.lineWeight !== void 0) result2.lineWeight = points(edit.lineWeight, 0, 100);
+    for (const [name, maximum] of [
+      ["linePattern", 23],
+      ["fillPattern", 24]
+    ]) {
+      if (edit[name] === void 0) continue;
+      const value = points(edit[name], 0, maximum);
+      if (!Number.isInteger(value)) fail2("INVALID_EDIT", "Paint patterns require integers.");
+      result2[name] = value;
+    }
+    for (const name of ["lineTransparency", "fillTransparency"])
+      if (edit[name] !== void 0) result2[name] = Math.round(points(edit[name], 0, 100) * 2) / 2;
+    if (edit.fillBackgroundColor !== void 0)
+      result2.fillBackgroundColor = color2(edit.fillBackgroundColor);
+    if (result2.fillColor === "none" && result2.fillPattern !== void 0 && result2.fillPattern !== 0)
+      fail2("INVALID_EDIT", "No fill conflicts with a visible fill pattern.");
+  }
+  if (Object.keys(result2).length === 3)
+    fail2("INVALID_EDIT", "Formatting requires at least one property.");
+  return result2;
+}
+
+// visio/edit-commands.ts
+var isVisioPageEdit = (edit) => edit.type === "insert-page" || edit.type === "reorder-page" || edit.type === "rename-page" || edit.type === "delete-page";
+function geometryChangedCells(edit) {
+  if (edit.type === "create-line")
+    return [
+      "BeginX",
+      "BeginY",
+      "EndX",
+      "EndY",
+      "PinX",
+      "PinY",
+      "Width",
+      "Height",
+      "Angle",
+      "LocPinX",
+      "LocPinY"
+    ];
+  if (edit.type === "delete-shape") return [];
+  if (edit.type === "create-text-box")
+    return ["PinX", "PinY", "Width", "Height", "LinePattern", "FillPattern"];
+  if (edit.type === "move-line-endpoint") {
+    const prefix = edit.endpoint === "begin" ? "Begin" : "End";
+    return [`${prefix}X`, `${prefix}Y`];
+  }
+  if (edit.type === "move-shape") return ["PinX", "PinY"];
+  if (edit.type === "resize-shape")
+    return edit.anchor ? ["Width", "Height", "PinX", "PinY", "LocPinX", "LocPinY"] : ["Width", "Height"];
+  if (edit.type === "rotate-shape") return ["Angle"];
+  if (edit.type === "flip-shape") return ["Angle", edit.axis === "horizontal" ? "FlipX" : "FlipY"];
+  return ["PinX", "PinY", "Width", "Height"];
+}
+function snapshotVisioEdits(edits, maxEdits, maxText) {
+  if (!Array.isArray(edits) || edits.length > maxEdits)
+    fail2("LIMIT_EDITS", "Edit command count exceeds limit.");
+  let textLength = 0;
+  const text2 = (value) => {
+    if (typeof value !== "string") fail2("INVALID_EDIT", "Edit text must be a string.");
+    textLength += value.length;
+    if (textLength > maxText) fail2("LIMIT_EDIT_TEXT", "Replacement text exceeds aggregate limit.");
+    if (/[\u0000-\u0008\u000b\u000c\u000d\u000e-\u001f\ufffe\uffff]|[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/u.test(
+      value
+    ))
+      fail2("INVALID_EDIT_TEXT", "Replacement text contains invalid XML characters.");
+    return value;
+  };
+  const numeric5 = (value, dimension2 = false, allowZero = false) => {
+    if (typeof value !== "number" || !Number.isFinite(value) || Math.abs(value) > 1e6 || dimension2 && (value < 0 || !allowZero && value === 0))
+      fail2(
+        "INVALID_EDIT",
+        "Geometry requires finite drawing inches within limits and positive dimensions."
+      );
+    return value;
+  };
+  return Array.from(edits, (edit) => {
+    if (!edit || typeof edit.pageId !== "string" || !edit.pageId || edit.pageId.length > 256)
+      fail2("INVALID_EDIT", "Invalid edit target.");
+    if (edit.type === "duplicate-shapes") return snapshotDuplicateShapes(edit);
+    if (edit.type === "paste-shapes") return snapshotPasteShapes(edit);
+    if (edit.type === "delete-page") return { type: edit.type, pageId: edit.pageId };
+    if (edit.type === "reorder-page") {
+      if (!Number.isSafeInteger(edit.index) || edit.index < 0 || edit.index > 1e6)
+        fail2("INVALID_EDIT", "Page order requires a bounded zero-based integer index.");
+      return { type: edit.type, pageId: edit.pageId, index: edit.index };
+    }
+    if (edit.type === "insert-page") {
+      const name = text2(edit.name);
+      if (!/^(0|[1-9]\d{0,9})$/.test(edit.pageId) || Number(edit.pageId) > 4294967295 || typeof edit.afterPageId !== "string" || !edit.afterPageId || edit.afterPageId.length > 256 || !name.trim() || name.length > 256 || /[\t\n]/.test(name))
+        fail2("INVALID_EDIT", "Invalid new page ID, name or insertion target.");
+      return { type: edit.type, pageId: edit.pageId, afterPageId: edit.afterPageId, name };
+    }
+    if (edit.type === "rename-page") {
+      const name = text2(edit.name);
+      if (!name.trim() || name.length > 255 || /[\t\n]/.test(name))
+        fail2("INVALID_EDIT", "Invalid page name.");
+      return { type: edit.type, pageId: edit.pageId, name };
+    }
+    if (typeof edit.shapeId !== "string" || !edit.shapeId || edit.shapeId.length > 256)
+      fail2("INVALID_EDIT", "Invalid edit shape target.");
+    const target = { pageId: edit.pageId, shapeId: edit.shapeId };
+    if (edit.type === "replace-plain-text")
+      return { ...target, type: edit.type, text: text2(edit.text) };
+    if (isVisioFormatEdit(edit)) return snapshotFormatting(edit);
+    if (edit.type === "reorder-shape") {
+      if (!["front", "back", "forward", "backward"].includes(edit.order))
+        fail2("INVALID_EDIT", "Invalid shape order.");
+      return { ...target, type: edit.type, order: edit.order };
+    }
+    if (!/^[1-9]\d{0,9}$/.test(edit.shapeId) || Number(edit.shapeId) > 4294967295)
+      fail2("INVALID_EDIT", "Geometry shape IDs must be canonical positive unsigned integers.");
+    switch (edit.type) {
+      case "create-text-box":
+        return {
+          ...target,
+          type: edit.type,
+          x: numeric5(edit.x),
+          y: numeric5(edit.y),
+          width: numeric5(edit.width, true),
+          height: numeric5(edit.height, true),
+          text: text2(edit.text)
+        };
+      case "create-line": {
+        const beginX = numeric5(edit.beginX), beginY = numeric5(edit.beginY);
+        const endX = numeric5(edit.endX), endY = numeric5(edit.endY);
+        numeric5(Math.hypot(endX - beginX, endY - beginY), true);
+        return { ...target, type: edit.type, beginX, beginY, endX, endY };
+      }
+      case "create-rectangle":
+      case "create-ellipse":
+        return {
+          ...target,
+          type: edit.type,
+          x: numeric5(edit.x),
+          y: numeric5(edit.y),
+          width: numeric5(edit.width, true),
+          height: numeric5(edit.height, true),
+          ...edit.text === void 0 ? {} : { text: text2(edit.text) }
+        };
+      case "rotate-shape":
+        return { ...target, type: edit.type, angle: numeric5(edit.angle) };
+      case "flip-shape":
+        if (edit.axis !== "horizontal" && edit.axis !== "vertical")
+          fail2("INVALID_EDIT", "Invalid flip axis.");
+        return { ...target, type: edit.type, axis: edit.axis };
+      case "move-shape":
+        return { ...target, type: edit.type, x: numeric5(edit.x), y: numeric5(edit.y) };
+      case "move-line-endpoint":
+        if (edit.endpoint !== "begin" && edit.endpoint !== "end")
+          fail2("INVALID_EDIT", "A line endpoint must be begin or end.");
+        return {
+          ...target,
+          type: edit.type,
+          endpoint: edit.endpoint,
+          x: numeric5(edit.x),
+          y: numeric5(edit.y)
+        };
+      case "resize-shape": {
+        const anchor = snapshotResizeAnchor(edit.anchor);
+        return {
+          ...target,
+          type: edit.type,
+          width: numeric5(edit.width, true),
+          height: numeric5(edit.height, true, true),
+          ...anchor === void 0 ? {} : { anchor }
+        };
+      }
+      case "delete-shape":
+        return { ...target, type: edit.type };
+      default:
+        return fail2("INVALID_EDIT", "Unsupported edit command.");
+    }
+  });
+}
+
 // visio/edit-group-rotation.ts
 function proveLocalGroupRotation(root, edit, check3) {
   const groups = /* @__PURE__ */ new Set(), angleCells = /* @__PURE__ */ new Set();
@@ -45673,6 +46343,238 @@ function proveLocalGroupRotation(root, edit, check3) {
   return { groups, angleCells };
 }
 
+// visio/edit-resize-anchor.ts
+var close = (a2, b) => Math.abs(a2 - b) <= 1e-10 * Math.max(1, Math.abs(a2), Math.abs(b));
+function closure(graph, changed, check3) {
+  const reverse2 = /* @__PURE__ */ new Map();
+  for (const [id, item] of graph) {
+    check3();
+    for (const dependency of item.dependencies) {
+      const list = reverse2.get(dependency) ?? [];
+      list.push(id);
+      reverse2.set(dependency, list);
+    }
+  }
+  const affected = new Set(changed), pending2 = [...changed];
+  for (let index2 = 0; index2 < pending2.length; index2++) {
+    check3();
+    for (const id of reverse2.get(pending2[index2]) ?? [])
+      if (!affected.has(id)) {
+        affected.add(id);
+        pending2.push(id);
+      }
+    if (affected.size > 1e4)
+      fail2("LIMIT_FORMULA_AFFECTED", "Affected ShapeSheet cell limit exceeded.");
+  }
+  return affected;
+}
+function resizeVisioShapeAtAnchor(roots, document, edit, check3) {
+  check3();
+  const root = roots.get(edit.pageId);
+  if (!root) fail2("EDIT_TARGET_NOT_FOUND", "Page does not exist.");
+  const shape2 = admitted(root, edit.shapeId);
+  const local = cells(shape2);
+  const canonical = [
+    "Width",
+    "Height",
+    "PinX",
+    "PinY",
+    "LocPinX",
+    "LocPinY",
+    "Angle",
+    "FlipX",
+    "FlipY",
+    "LockMoveX",
+    "LockMoveY",
+    "LockWidth",
+    "LockHeight",
+    "LockAspect",
+    "LockDelete"
+  ];
+  for (const name of local.keys())
+    if (canonical.some(
+      (expected) => expected.toLowerCase() === name.toLowerCase() && expected !== name
+    ))
+      fail2(
+        "EDIT_AMBIGUOUS_CELL",
+        "Noncanonical transform and protection cell names are unsupported."
+      );
+  if (!edit.anchor || isLineSheet(cells(shape2)) || edit.height <= 0)
+    fail2("UNSUPPORTED_GEOMETRY_EDIT", "Anchored resizing requires an ordinary local 2D shape.");
+  if (Array.from(shape2.getElementsByTagName("*")).some(
+    (node) => node.localName === "Shape" && [VISIO_NS, VISIO_LEGACY_NS].includes(node.namespaceURI ?? "")
+  ))
+    fail2("UNSUPPORTED_GEOMETRY_EDIT", "Nested shape identities cannot be resized as a local leaf.");
+  protectedShape(shape2, document);
+  assertUnlayeredShape(shape2, document);
+  for (const container of children3(root, "Connects"))
+    for (const connection of children3(container, "Connect"))
+      if (["FromSheet", "ToSheet"].some((name) => attribute3(connection, name) === edit.shapeId))
+        fail2("UNSUPPORTED_GEOMETRY_EDIT", "Glued shapes require routing outside this subset.");
+  const graph = indexCells(roots, { check: check3 });
+  const id = (cell) => key({ pageId: edit.pageId, shapeId: edit.shapeId, cell });
+  const source2 = createVisioCellEvaluator(graph, { check: check3 }, true);
+  const read = (name, fallback) => graph.has(id(name)) ? source2(id(name)).value : numeric4(local.get(name), fallback);
+  const width = read("Width"), height = read("Height");
+  const pinX = read("PinX", width / 2), pinY = read("PinY", height / 2);
+  const locX = read("LocPinX", width / 2), locY = read("LocPinY", height / 2);
+  const angle = read("Angle", 0), flipX = read("FlipX", 0), flipY = read("FlipY", 0);
+  for (const name of ["Angle", "FlipX", "FlipY"]) {
+    const unit = attribute3(local.get(name), "U");
+    if (unit && visioFormulaCachedValue("0", unit).unit !== (name === "Angle" ? "angle" : "scalar"))
+      fail2("EDIT_FORMULA_UNIT", "Rotation and flip cells require their declared dimensions.");
+  }
+  if (![0, 1].includes(flipX) || ![0, 1].includes(flipY))
+    fail2("EDIT_FORMULA_UNIT", "Flip cells must be scalar booleans.");
+  if (width === edit.width && height === edit.height) return [];
+  resizeGeometry(shape2, roots, edit, check3);
+  if (numeric4(local.get("LockAspect"), 0) !== 0 && !close(edit.width / width, edit.height / height))
+    fail2("EDIT_PROTECTED_CELL", "LockAspect prevents changing the aspect ratio.");
+  const geometry = visioAnchoredResizeGeometry(
+    {
+      width,
+      height,
+      pinX,
+      pinY,
+      transform: transform6(pinX, pinY, locX, locY, angle, flipX === 1, flipY === 1)
+    },
+    edit,
+    edit.anchor
+  );
+  if (!geometry || [geometry.pinX, geometry.pinY, geometry.locPinX, geometry.locPinY].some(
+    (value) => Math.abs(value) > 1e6
+  ))
+    fail2("UNSUPPORTED_GEOMETRY_EDIT", "Anchored geometry exceeds coordinate limits.");
+  const writes = [];
+  const writable = (name) => editableCell(
+    local.get(name),
+    (reference2) => source2(
+      key({
+        pageId: edit.pageId,
+        shapeId: reference2.shapeId ?? edit.shapeId,
+        cell: reference2.cell
+      })
+    )
+  );
+  const unlocked = (name) => {
+    if (numeric4(local.get(name), 0) !== 0)
+      fail2("EDIT_PROTECTED_CELL", `${name} prevents this operation.`);
+  };
+  for (const [name, value, old] of [
+    ["Width", edit.width, width],
+    ["Height", edit.height, height]
+  ])
+    if (value !== old) {
+      unlocked(`Lock${name}`);
+      writable(name);
+      writes.push({ name, value });
+    }
+  const changedDimensions = writes.map((write) => id(write.name));
+  const dimensionClosure = closure(graph, changedDimensions, check3);
+  for (const [name, value, old] of [
+    ["PinX", geometry.pinX, pinX],
+    ["PinY", geometry.pinY, pinY]
+  ])
+    if (!local.has(name) || !close(value, old) || dimensionClosure.has(id(name)) && !guardedCell(local.get(name))) {
+      if (!close(value, old)) unlocked(name === "PinX" ? "LockMoveX" : "LockMoveY");
+      writable(name);
+      writes.push({ name, value: close(value, old) ? old : value });
+    }
+  const projected = new Map(graph);
+  const install = (write) => {
+    const original = local.get(write.name);
+    const node = original ? original.cloneNode(true) : shape2.ownerDocument.createElementNS(shape2.namespaceURI, "Cell");
+    node.setAttribute("N", write.name);
+    node.setAttribute("V", String(write.value));
+    if (write.formula) node.setAttribute("F", write.formula);
+    else node.removeAttribute("F");
+    const cell = {
+      pageId: edit.pageId,
+      shapeId: edit.shapeId,
+      cell: write.name,
+      node,
+      unsafe: false,
+      unit: "length",
+      dependencies: []
+    };
+    if (write.formula) {
+      cell.formula = parseVisioFormula(write.formula);
+      cell.dependencies = [id(write.name === "LocPinX" ? "Width" : "Height")];
+    }
+    projected.set(id(write.name), cell);
+  };
+  for (const write of writes) install(write);
+  const guardedPins = [];
+  for (const [name, dimension2, old, oldDimension, next] of [
+    ["LocPinX", "Width", locX, width, geometry.locPinX],
+    ["LocPinY", "Height", locY, height, geometry.locPinY]
+  ]) {
+    if ((dimension2 === "Width" ? edit.width : edit.height) === oldDimension) continue;
+    if (guardedCell(local.get(name))) {
+      guardedPins.push({ name, value: next });
+    } else {
+      writable(name);
+      const write = { name, value: next, formula: `${dimension2}*${old / oldDimension}` };
+      writes.push(write);
+      install(write);
+    }
+  }
+  const projectedPins = createVisioCellEvaluator(projected, { check: check3 });
+  for (const pin of guardedPins)
+    if (!close(projectedPins(id(pin.name)).value, pin.value))
+      fail2(
+        "EDIT_PROTECTED_CELL",
+        "Guarded local pin does not scale proportionally with the requested dimension."
+      );
+  const affected = closure(
+    projected,
+    writes.map((write) => id(write.name)),
+    check3
+  );
+  for (const name of ["Angle", "FlipX", "FlipY"])
+    if (affected.has(id(name)))
+      fail2(
+        "UNSUPPORTED_GEOMETRY_EDIT",
+        "Anchored resizing cannot change dependent Angle or Flip formulas."
+      );
+  for (const cellId of affected)
+    if (/^Field\./i.test(projected.get(cellId).cell))
+      fail2(
+        "UNSUPPORTED_GEOMETRY_EDIT",
+        "Affected text fields need native display-cache regeneration."
+      );
+  const evaluate = createVisioCellEvaluator(projected, { check: check3 }), values2 = /* @__PURE__ */ new Map();
+  for (const cellId of affected) {
+    if (graph.has(cellId)) source2(cellId);
+    values2.set(cellId, evaluate(cellId).value);
+  }
+  for (const [name, expected] of [
+    ["Width", edit.width],
+    ["Height", edit.height],
+    ["PinX", geometry.pinX],
+    ["PinY", geometry.pinY],
+    ["LocPinX", geometry.locPinX],
+    ["LocPinY", geometry.locPinY]
+  ])
+    if (!close(projected.has(id(name)) ? evaluate(id(name)).value : read(name), expected))
+      fail2(
+        "EDIT_UNSUPPORTED_DEPENDENCY",
+        "Dependent formulas would violate the requested anchor or dimensions."
+      );
+  check3();
+  for (const write of writes) setCell(shape2, write.name, write.value, write.formula);
+  const dirty = /* @__PURE__ */ new Set([edit.pageId]);
+  for (const [cellId, value] of values2) {
+    const item = graph.get(cellId);
+    if (!item?.node || !item.formula || writes.some((write) => id(write.name) === cellId)) continue;
+    if (attribute3(item.node, "V") !== String(value)) {
+      item.node.setAttribute("V", String(value));
+      dirty.add(item.pageId);
+    }
+  }
+  return [...dirty];
+}
+
 // visio/edit-transform-formula.ts
 function editableTransformCell(roots, edit, node, check3, options = {}) {
   const formula = executableCellFormula(attribute3(node, "F"));
@@ -45742,7 +46644,16 @@ function createBox(root, document, edit) {
   return shape2;
 }
 function createRectangle(root, document, edit) {
+  if (edit.type === "create-text-box") {
+    const planned = root.ownerDocument.createElementNS(root.namespaceURI, "Shape");
+    applyShapeCreationStyles(planned, document);
+    assertShapeLocks(planned, document, ["LockTextEdit"]);
+  }
   const shape2 = createBox(root, document, edit);
+  if (edit.type === "create-text-box") {
+    setCell(shape2, "LinePattern", 0);
+    setCell(shape2, "FillPattern", 0);
+  }
   const doc = root.ownerDocument;
   const node = (name) => doc.createElementNS(root.namespaceURI, name);
   const section = node("Section");
@@ -45764,7 +46675,7 @@ function createRectangle(root, document, edit) {
   }
   shape2.appendChild(section);
   const text2 = node("Text");
-  text2.appendChild(doc.createTextNode(edit.text ?? ""));
+  text2.appendChild(doc.createTextNode(encodeVisioPlainText(edit.text ?? "")));
   shape2.appendChild(text2);
   return shape2;
 }
@@ -45773,7 +46684,7 @@ function createEllipse(root, document, edit) {
   appendEllipseGeometry(shape2, edit.width, edit.height);
   if (edit.text !== void 0) {
     const text2 = root.ownerDocument.createElementNS(root.namespaceURI, "Text");
-    text2.appendChild(root.ownerDocument.createTextNode(edit.text));
+    text2.appendChild(root.ownerDocument.createTextNode(encodeVisioPlainText(edit.text)));
     shape2.appendChild(text2);
   }
   return shape2;
@@ -46143,6 +47054,8 @@ function moveLocalLineEndpoint(shape2, edit) {
 function applyGeometryEdit(roots, document, edit, check3, masterMoveProof = emptyMasterMoveProof()) {
   const masterMovePins = masterMoveProof.pins, masterDimensions = masterMoveProof.dimensions;
   check3();
+  if (edit.type === "resize-shape" && edit.anchor)
+    return resizeVisioShapeAtAnchor(roots, document, edit, check3);
   const root = roots.get(edit.pageId);
   if (!root) fail2("EDIT_TARGET_NOT_FOUND", "Page does not exist.");
   const groupRotation = proveLocalGroupRotation(root, edit, check3);
@@ -46164,11 +47077,15 @@ function applyGeometryEdit(roots, document, edit, check3, masterMoveProof = empt
       y: (edit.beginY + edit.endY) / 2
     };
     for (const name of geometryChangedCells(edit)) add3(name);
-  } else if (edit.type === "create-rectangle" || edit.type === "create-ellipse") {
+  } else if (edit.type === "create-rectangle" || edit.type === "create-ellipse" || edit.type === "create-text-box") {
     if (edit.type === "create-ellipse") createEllipse(root, document, edit);
     else createRectangle(root, document, edit);
     expected = { width: edit.width, height: edit.height, x: edit.x, y: edit.y };
     for (const name of ["Width", "Height", "PinX", "PinY"]) add3(name);
+    if (edit.type === "create-text-box") {
+      add3("LinePattern");
+      add3("FillPattern");
+    }
   } else {
     const shape2 = admitted(
       root,
@@ -46361,6 +47278,114 @@ function applyGeometryEdit(roots, document, edit, check3, masterMoveProof = empt
   return [.../* @__PURE__ */ new Set([edit.pageId, ...affectedPages])];
 }
 
+// visio/edit-shape-order.ts
+async function assertShapeOrderPackageScope(pkg, check3) {
+  for (const path2 of pkg.paths()) {
+    if (!/^visio\/.*\.xml$/i.test(path2)) continue;
+    const pending2 = [await pkg.readXml(path2)];
+    while (pending2.length) {
+      check3();
+      const node = pending2.pop();
+      const source2 = executableCellFormula(attribute3(node, "F"));
+      if (source2) {
+        try {
+          if (analyzeVisioFormula(source2, { onStep: check3 }).dynamic)
+            fail2(
+              "UNSUPPORTED_SHAPE_ORDER",
+              "Dynamic or container formulas may depend on stacking order."
+            );
+        } catch {
+          fail2(
+            "UNSUPPORTED_SHAPE_ORDER",
+            "Package formulas cannot be proven independent of stacking order."
+          );
+        }
+      }
+      for (const child6 of Array.from(node.childNodes))
+        if (child6.nodeType === 1) pending2.push(child6);
+    }
+  }
+}
+function ordinaryDisplayBand(shape2, document) {
+  for (const category of ["LineStyle", "FillStyle", "TextStyle"]) {
+    const node = effectiveShapeCell(shape2, document, "DisplayLevel", category);
+    if (!node) continue;
+    const cached3 = visioFormulaCachedValue(attribute3(node, "V") ?? "", attribute3(node, "U"));
+    if (node.hasAttribute("E") || cached3.unit !== "scalar" || cached3.value !== 0)
+      fail2("UNSUPPORTED_SHAPE_ORDER", "Only the ordinary zero display band can be reordered.");
+    const source2 = executableCellFormula(attribute3(node, "F"));
+    if (!source2) continue;
+    const analysis = analyzeVisioFormula(source2);
+    if (analysis.dynamic || analysis.references.length || analysis.unsupportedFunctions.length)
+      fail2("UNSUPPORTED_SHAPE_ORDER", "Display band formulas must be constant.");
+    const result2 = evaluateVisioFormula(
+      source2,
+      () => fail2("UNSUPPORTED_SHAPE_ORDER", "Display band dependencies cannot be resolved.")
+    );
+    if (result2.unit !== "scalar" || result2.value !== cached3.value)
+      fail2("UNSUPPORTED_SHAPE_ORDER", "Display band formula cache is stale.");
+  }
+}
+function reorderVisioShape(root, document, edit, check3) {
+  check3();
+  const containers = children3(root, "Shapes");
+  if (containers.length !== 1)
+    fail2("UNSUPPORTED_SHAPE_ORDER", "One local Shapes container is required.");
+  const container = containers[0];
+  const siblings = children3(container, "Shape");
+  const ids = /* @__PURE__ */ new Set();
+  for (const shape2 of siblings) {
+    check3();
+    const id = attribute3(shape2, "ID");
+    if (!id || ids.has(id)) fail2("INVALID_SHAPE_ID", "Shape IDs must be present and unique.");
+    ids.add(id);
+    if (shape2.hasAttribute("Master") || shape2.hasAttribute("MasterShape") || shape2.hasAttribute("Del") || children3(shape2, "Shapes").length || children3(shape2, "ForeignData").length || children3(shape2, "Rel").length || attribute3(shape2, "Type") !== void 0 && attribute3(shape2, "Type") !== "Shape")
+      fail2(
+        "UNSUPPORTED_SHAPE_ORDER",
+        "Ordering requires local ordinary shapes in one display band."
+      );
+    ordinaryDisplayBand(shape2, document);
+  }
+  const index2 = siblings.findIndex((shape2) => attribute3(shape2, "ID") === edit.shapeId);
+  if (index2 < 0) fail2("EDIT_TARGET_NOT_FOUND", "A top-level local shape is required.");
+  const target = siblings[index2];
+  assertShapeLocks(target, document, ["LockSelect", "LockFormat"]);
+  assertUnlayeredShape(target, document);
+  const destination = edit.order === "front" ? siblings.length - 1 : edit.order === "back" ? 0 : edit.order === "forward" ? Math.min(siblings.length - 1, index2 + 1) : Math.max(0, index2 - 1);
+  if (destination === index2) return false;
+  const anchor = siblings[destination];
+  container.insertBefore(target, destination > index2 ? anchor.nextSibling : anchor);
+  return true;
+}
+
+// visio/edit-duplicate-scope.ts
+async function assertDuplicateScope(pkg, pagePaths, targetPage, newIds, check3) {
+  const existing = /* @__PURE__ */ new Set();
+  for (const node of Array.from(targetPage.getElementsByTagName("*"))) {
+    check3();
+    if (node.localName !== "Shape" || node.namespaceURI !== targetPage.namespaceURI) continue;
+    const id = attribute3(node, "ID");
+    if (!id || existing.has(id)) fail2("INVALID_SHAPE_ID", "Source shape IDs must be unique.");
+    if (newIds.has(id)) fail2("INVALID_SHAPE_ID", "New shape ID already exists.");
+    existing.add(id);
+  }
+  await assertShapeOrderPackageScope(pkg, check3);
+  const inspect2 = (root) => {
+    for (const node of [root, ...Array.from(root.getElementsByTagName("*"))]) {
+      check3();
+      const source2 = executableCellFormula(attribute3(node, "F"));
+      if (!source2) continue;
+      if (analyzeVisioFormula(source2).references.some(
+        (ref) => ref.shapeId !== void 0 && newIds.has(ref.shapeId)
+      ))
+        fail2("EDIT_DUPLICATE_DEPENDENCY", "New IDs are already referenced by existing formulas.");
+    }
+  };
+  inspect2(targetPage);
+  for (const path2 of pkg.paths())
+    if (/^visio\/.*\.xml$/i.test(path2) && !pagePaths.has(path2)) inspect2(await pkg.readXml(path2));
+}
+
 // visio/formula-master.ts
 function analyzeVisioMasterFormula(source2, options) {
   const ast = parseVisioFormula(source2);
@@ -46992,10 +48017,17 @@ async function assertGeometryPackageScope(pkg, pagePaths, commands, check3, root
   for (const [pageId, root] of roots) {
     const shapes = Array.from(root.getElementsByTagNameNS(root.namespaceURI, "Shape"));
     for (const command2 of commands)
-      if ((command2.type === "create-rectangle" || command2.type === "create-ellipse" || command2.type === "create-line") && command2.pageId === pageId && !shapes.some((shape2) => attribute3(shape2, "ID") === command2.shapeId)) {
+      if ((command2.type === "create-rectangle" || command2.type === "create-ellipse" || command2.type === "create-text-box" || command2.type === "create-line") && command2.pageId === pageId && !shapes.some((shape2) => attribute3(shape2, "ID") === command2.shapeId)) {
         const shape2 = root.ownerDocument.createElementNS(root.namespaceURI, "Shape");
         shape2.setAttribute("ID", command2.shapeId);
         applyShapeCreationStyles(shape2, documentRoot);
+        if (command2.type === "create-text-box")
+          for (const name of ["LinePattern", "FillPattern"]) {
+            const node = root.ownerDocument.createElementNS(root.namespaceURI, "Cell");
+            node.setAttribute("N", name);
+            node.setAttribute("V", "0");
+            shape2.appendChild(node);
+          }
         for (const name of ["PinX", "PinY", "Width", "Height", "LocPinX", "LocPinY", "Angle"]) {
           const node = root.ownerDocument.createElementNS(root.namespaceURI, "Cell");
           node.setAttribute("N", name);
@@ -47736,6 +48768,787 @@ async function editVsdxPages(original, pkg, parts, commands, limits, maxOutput,
   };
 }
 
+// visio/edit-formatting-font.ts
+function formattingFont(document, family) {
+  const containers = children3(document, "FaceNames");
+  if (containers.length !== 1)
+    fail2("UNSUPPORTED_FORMAT_EDIT", "Font family requires existing document FaceNames.");
+  const fonts = children3(containers[0], "FaceName");
+  const ids = /* @__PURE__ */ new Set();
+  for (const font3 of fonts) {
+    const id2 = attribute3(font3, "ID");
+    if (id2 === void 0) continue;
+    if (!/^\d+$/.test(id2) || ids.has(id2))
+      fail2("UNSUPPORTED_FORMAT_EDIT", "Explicit document font IDs must be numeric and unique.");
+    ids.add(id2);
+  }
+  const matches2 = fonts.filter(
+    (font3) => (attribute3(font3, "Name") ?? attribute3(font3, "NameU"))?.toLowerCase() === family.toLowerCase()
+  );
+  if (matches2.length !== 1)
+    fail2("UNSUPPORTED_FORMAT_EDIT", "Font family must match one existing document FaceName.");
+  const font2 = matches2[0], id = attribute3(font2, "ID");
+  if (id !== void 0) return { value: id };
+  const name = attribute3(font2, "Name") ?? attribute3(font2, "NameU");
+  return { value: name, formula: `FONT("${name.replaceAll('"', '""')}")` };
+}
+
+// visio/edit-formatting-text.ts
+function textFormattingWrites(shape2, document, edit, check3) {
+  const rows = /* @__PURE__ */ new Map();
+  if (["fontSize", "fontFamily", "fontColor", "bold", "italic", "underline", "strikethrough"].some(
+    (key2) => edit[key2] !== void 0
+  ))
+    rows.set("Character", formattingRowContext(shape2, document, "Character"));
+  if (edit.bullets !== void 0 || edit.indentLeft !== void 0 || edit.horizontalAlign !== void 0)
+    rows.set("Paragraph", formattingRowContext(shape2, document, "Paragraph"));
+  const characters = rows.get("Character")?.source;
+  const paragraphs = rows.get("Paragraph")?.source;
+  if (rows.size) assertFormattingText(shape2, characters, paragraphs);
+  const writes = [];
+  const add3 = (name, value, unit, formula) => writes.push({
+    name,
+    value: String(value),
+    category: "TextStyle",
+    ...unit ? { unit } : {},
+    ...formula ? { formula } : {}
+  });
+  const scalar4 = (name, max, description) => {
+    const cell = effectiveShapeCell(
+      shape2,
+      document,
+      name,
+      "TextStyle",
+      rows.get(name.split(".")[0])
+    );
+    const cached3 = cell ? visioFormulaCachedValue(attribute3(cell, "V") ?? "", attribute3(cell, "U")) : { value: 0, unit: "scalar" };
+    if (cached3.unit !== "scalar" || !Number.isSafeInteger(cached3.value) || cached3.value < 0 || cached3.value > max)
+      fail2("UNSUPPORTED_FORMAT_EDIT", `${description} requires a supported scalar value.`);
+    return cached3.value;
+  };
+  const font2 = edit.fontFamily === void 0 ? void 0 : formattingFont(document, edit.fontFamily);
+  for (const index2 of characters ? /* @__PURE__ */ new Set(["0", ...characters.keys()]) : []) {
+    check3();
+    const name = (cell) => `Character.${index2}.${cell}`;
+    if (edit.fontSize !== void 0) add3(name("Size"), edit.fontSize / 72, "PT");
+    if (font2) add3(name("Font"), font2.value, void 0, font2.formula);
+    if (edit.fontColor !== void 0) {
+      add3(
+        name("Color"),
+        edit.fontColor,
+        void 0,
+        `RGB(${[1, 3, 5].map((i2) => parseInt(edit.fontColor.slice(i2, i2 + 2), 16)).join(",")})`
+      );
+      add3(name("ColorTrans"), 0);
+    }
+    if (edit.strikethrough !== void 0) add3(name("Strikethru"), edit.strikethrough ? 1 : 0);
+    if ([edit.bold, edit.italic, edit.underline].some((value) => value !== void 0)) {
+      let bits = scalar4(name("Style"), 255, "Character style");
+      for (const [value, bit] of [
+        [edit.bold, 1],
+        [edit.italic, 2],
+        [edit.underline, 4]
+      ])
+        if (value !== void 0) bits = value ? bits | bit : bits & ~bit;
+      add3(name("Style"), bits);
+    }
+  }
+  for (const index2 of paragraphs ? /* @__PURE__ */ new Set(["0", ...paragraphs.keys()]) : []) {
+    check3();
+    const name = (cell) => `Paragraph.${index2}.${cell}`;
+    if (edit.indentLeft !== void 0) add3(name("IndLeft"), edit.indentLeft / 72, "PT");
+    if (edit.bullets !== void 0) {
+      const bullet = scalar4(name("Bullet"), 7, "Paragraph bullet style");
+      add3(name("Bullet"), edit.bullets ? bullet || 1 : 0);
+    }
+    if (edit.horizontalAlign !== void 0)
+      add3(name("HorzAlign"), ["left", "center", "right", "justify"].indexOf(edit.horizontalAlign));
+  }
+  if (edit.verticalAlign !== void 0)
+    add3("VerticalAlign", ["top", "middle", "bottom"].indexOf(edit.verticalAlign));
+  return { writes, rows };
+}
+
+// visio/edit-formatting-paint-scope.ts
+var selectors = [
+  "ColorSchemeIndex",
+  "EffectSchemeIndex",
+  "ConnectorSchemeIndex",
+  "VariationStyleIndex",
+  "VariationColorIndex",
+  "QuickStyleType",
+  "QuickStyleVariation",
+  "QuickStyleFillMatrix",
+  "QuickStyleLineMatrix",
+  "OneD"
+];
+function scalar3(cell) {
+  if (!cell) return void 0;
+  if (cell.hasAttribute("E")) fail2("UNSUPPORTED_FORMAT_EDIT", "Paint state has an error cache.");
+  const cached3 = visioFormulaCachedValue(attribute3(cell, "V") ?? "", attribute3(cell, "U"));
+  if (cached3.unit !== "scalar") fail2("EDIT_FORMULA_UNIT", "Paint state requires scalar units.");
+  const source2 = executableCellFormula(attribute3(cell, "F"));
+  if (source2) {
+    const analysis = analyzeVisioFormula(source2);
+    if (analysis.dynamic || analysis.references.length || analysis.unsupportedFunctions.length)
+      fail2("UNSUPPORTED_FORMAT_EDIT", "Paint state dependencies cannot be proven.");
+    const actual = evaluateVisioFormula(
+      source2,
+      () => fail2("UNSUPPORTED_FORMAT_EDIT", "Unknown paint dependency.")
+    );
+    if (actual.unit !== "scalar" || actual.value !== cached3.value)
+      fail2("UNSUPPORTED_FORMAT_EDIT", "Paint state formula cache is stale.");
+  }
+  return cached3.value;
+}
+async function assertNonGradientPaint(pkg, document, shape2, pageId, paint2, check3) {
+  const category = paint2 === "Fill" ? "FillStyle" : "LineStyle";
+  const pattern = effectiveShapeCell(shape2, document, `${paint2}Pattern`, category);
+  if (pattern && attribute3(pattern, "V") !== "Themed") {
+    const value = scalar3(pattern);
+    if (value === 0) return;
+    if (paint2 === "Fill" && value !== void 0 && value >= 25)
+      fail2("UNSUPPORTED_FORMAT_EDIT", "Classic gradient and custom fill edits are unsupported.");
+  }
+  const enabled2 = effectiveShapeCell(shape2, document, `${paint2}GradientEnabled`, category);
+  if (!enabled2) return;
+  if (attribute3(enabled2, "V") !== "Themed") {
+    if (scalar3(enabled2) === 0) return;
+    fail2(
+      "UNSUPPORTED_FORMAT_EDIT",
+      "Gradient paint transparency and background edits are unsupported."
+    );
+  }
+  assertEditableFormattingCell(enabled2);
+  const report = () => fail2("UNSUPPORTED_FORMAT_EDIT", "Theme paint context cannot be resolved safely.");
+  if (children3(document, "StyleSheets").length > 1)
+    fail2("UNSUPPORTED_FORMAT_EDIT", "Ambiguous style containers cannot supply theme paint.");
+  const styles = /* @__PURE__ */ new Map();
+  for (const container of children3(document, "StyleSheets"))
+    for (const node of children3(container, "StyleSheet")) {
+      check3();
+      const id = attribute3(node, "ID");
+      if (!id || styles.has(id)) fail2("UNSUPPORTED_FORMAT_EDIT", "Ambiguous style IDs.");
+      uniqueFormattingCells(node);
+      styles.set(id, {
+        sheet: readSheet(node),
+        attributes: new Map(Array.from(node.attributes).map((item) => [item.name, item.value]))
+      });
+    }
+  const context = { styles, styleCache: /* @__PURE__ */ new Map(), report, checkTime: check3 };
+  let sheet = emptySheet();
+  for (const name of ["LineStyle", "FillStyle", "TextStyle"]) {
+    for (const selector of selectors) scalar3(effectiveShapeCell(shape2, document, selector, name));
+    const id = attribute3(shape2, name) ?? attribute3(child5(document, "DocumentSheet"), name) ?? (styles.has("0") ? "0" : void 0);
+    if (id !== void 0) sheet = mergeSheets(sheet, styleSheet(id, name, context));
+  }
+  sheet = mergeSheets(sheet, readSheet(shape2));
+  const documentPath = await related(pkg, "", "document");
+  const pagesPath = await related(pkg, documentPath, "pages");
+  const page = children3(await visioXml(pkg, pagesPath, "Pages"), "Page").find(
+    (node) => attribute3(node, "ID") === pageId
+  );
+  const pageSheet = child5(page, "PageSheet");
+  const pageCells = /* @__PURE__ */ new Map();
+  if (pageSheet) uniqueFormattingCells(pageSheet);
+  for (const name of ["LineStyle", "FillStyle", "TextStyle"]) {
+    const id = attribute3(pageSheet, name);
+    if (id !== void 0 && pageSheet) {
+      for (const selector of selectors)
+        scalar3(effectiveShapeCell(pageSheet, document, selector, name));
+      for (const [key2, value] of styleSheet(id, name, context).cells)
+        if (/^(ColorSchemeIndex|EffectSchemeIndex|ConnectorSchemeIndex|FontSchemeIndex|VariationColorIndex|VariationStyleIndex)$/.test(
+          key2
+        ))
+          pageCells.set(key2, value);
+    }
+  }
+  for (const node of children3(pageSheet, "Cell"))
+    if (selectors.includes(attribute3(node, "N") ?? "")) scalar3(node);
+  const root = styles.get("0");
+  const resources = {
+    themes: await loadVisioThemes(pkg, documentPath, report),
+    pageCells: new Map([...pageCells, ...readSheet(pageSheet).cells]),
+    ...root?.attributes.get("NameU") === "No Style" ? { rootSheet: root.sheet } : {}
+  };
+  sheet = rootThemeSheet(sheet, resources, report);
+  const resolved = number(sheet.cells, `${paint2}GradientEnabled`, NaN);
+  if (resolved === 0) {
+    const source2 = styles.get("0");
+    if (!source2 || root?.attributes.get("NameU") !== "No Style")
+      fail2("UNSUPPORTED_FORMAT_EDIT", "Root gradient context cannot be proven.");
+    const node = children3(child5(document, "StyleSheets"), "StyleSheet").find(
+      (item) => attribute3(item, "ID") === "0"
+    );
+    if (scalar3(node ? uniqueFormattingCells(node).get(`${paint2}GradientEnabled`) : void 0) !== 0)
+      fail2("UNSUPPORTED_FORMAT_EDIT", "Root gradient state cannot be proven inactive.");
+    return;
+  }
+  const selected2 = themeFormat(sheet.cells, paint2, resources);
+  if (paint2 === "Fill" && selected2 && ["solidFill", "noFill"].includes(selected2.localName)) return;
+  if (paint2 === "Line" && selected2 && !themeChild(selected2, "gradFill") && (themeChild(selected2, "solidFill") || themeChild(selected2, "noFill")))
+    return;
+  fail2(
+    "UNSUPPORTED_FORMAT_EDIT",
+    "Active or unresolved theme gradients cannot be edited through paint transparency."
+  );
+}
+
+// visio/edit-formatting-paint.ts
+function shapeFormattingWrites(edit) {
+  const writes = /* @__PURE__ */ new Map();
+  const add3 = (name, value, category, unit, formula) => writes.set(name, {
+    name,
+    value: String(value),
+    category,
+    ...unit ? { unit } : {},
+    ...formula ? { formula } : {}
+  });
+  if (edit.fillColor !== void 0) {
+    add3("FillPattern", edit.fillColor === "none" ? 0 : 1, "FillStyle");
+    add3("FillGradientEnabled", 0, "FillStyle");
+    if (edit.fillColor !== "none") {
+      add3("FillForegnd", edit.fillColor, "FillStyle", void 0, rgb2(edit.fillColor));
+      add3("FillForegndTrans", 0, "FillStyle");
+    }
+  }
+  if (edit.fillPattern !== void 0) {
+    add3("FillPattern", edit.fillPattern, "FillStyle");
+    add3("FillGradientEnabled", 0, "FillStyle");
+  }
+  if (edit.fillBackgroundColor !== void 0) {
+    add3(
+      "FillBkgnd",
+      edit.fillBackgroundColor,
+      "FillStyle",
+      void 0,
+      rgb2(edit.fillBackgroundColor)
+    );
+  }
+  if (edit.fillTransparency !== void 0) {
+    for (const name of ["FillForegndTrans", "FillBkgndTrans"])
+      add3(name, edit.fillTransparency / 100, "FillStyle");
+  }
+  if (edit.lineColor !== void 0) {
+    add3("LineColor", edit.lineColor, "LineStyle", void 0, rgb2(edit.lineColor));
+    add3("LineColorTrans", 0, "LineStyle");
+    add3("LineGradientEnabled", 0, "LineStyle");
+  }
+  if (edit.linePattern !== void 0) add3("LinePattern", edit.linePattern, "LineStyle");
+  if (edit.lineTransparency !== void 0) {
+    add3("LineColorTrans", edit.lineTransparency / 100, "LineStyle");
+  }
+  if (edit.lineWeight !== void 0) add3("LineWeight", edit.lineWeight / 72, "LineStyle", "PT");
+  return [...writes.values()];
+}
+async function assertShapeFormattingPaintScope(pkg, document, shape2, edit, changed, check3) {
+  if (edit.fillColor === void 0 && edit.fillPattern === void 0 && ["FillBkgnd", "FillForegndTrans", "FillBkgndTrans"].some((name) => changed.has(name)))
+    await assertNonGradientPaint(pkg, document, shape2, edit.pageId, "Fill", check3);
+  if (edit.lineColor === void 0 && changed.has("LineColorTrans"))
+    await assertNonGradientPaint(pkg, document, shape2, edit.pageId, "Line", check3);
+}
+function rgb2(color2) {
+  return `RGB(${[1, 3, 5].map((index2) => parseInt(color2.slice(index2, index2 + 2), 16)).join(",")})`;
+}
+
+// visio/edit-formatting.ts
+function targetShape(root, shapeId) {
+  const containers = children3(root, "Shapes");
+  if (containers.length !== 1)
+    fail2("UNSUPPORTED_FORMAT_EDIT", "One local Shapes container is required.");
+  const candidates = children3(containers[0], "Shape").filter(
+    (shape3) => attribute3(shape3, "ID") === shapeId
+  );
+  if (candidates.length !== 1)
+    fail2("EDIT_TARGET_NOT_FOUND", "A unique top-level local shape is required.");
+  const shape2 = candidates[0];
+  if (shape2.hasAttribute("Master") || shape2.hasAttribute("MasterShape") || shape2.hasAttribute("Del") || children3(shape2, "Shapes").length || children3(shape2, "ForeignData").length || children3(shape2, "Rel").length || !["Shape", void 0].includes(attribute3(shape2, "Type")))
+    fail2(
+      "UNSUPPORTED_FORMAT_EDIT",
+      "Master, group, foreign, deleted and non-shape formatting is unsupported."
+    );
+  return shape2;
+}
+async function applyFormattingEdit(pkg, pagePaths, roots, document, edit, check3) {
+  const root = roots.get(edit.pageId);
+  if (!root) fail2("EDIT_TARGET_NOT_FOUND", "Page does not exist.");
+  const shape2 = targetShape(root, edit.shapeId);
+  assertUnlayeredShape(shape2, document);
+  assertShapeLocks(
+    shape2,
+    document,
+    edit.type === "format-text" ? ["LockFormat", "LockTextEdit"] : ["LockFormat"]
+  );
+  let writes = [];
+  let rows;
+  if (edit.type === "format-text") {
+    const plan = textFormattingWrites(shape2, document, edit, check3);
+    writes = plan.writes;
+    rows = plan.rows;
+  } else {
+    writes = shapeFormattingWrites(edit);
+  }
+  const changed = /* @__PURE__ */ new Map();
+  for (const write of writes) {
+    check3();
+    const [section, index2, name] = write.name.split(".");
+    const rowContext = rows?.get(section);
+    const effective = effectiveShapeCell(shape2, document, write.name, write.category, rowContext);
+    assertEditableFormattingCell(effective);
+    if (/^(LinePattern|FillPattern|FillGradientEnabled|LineGradientEnabled|LineColorTrans|FillForegndTrans|FillBkgndTrans|FillBkgnd)$/.test(
+      write.name
+    ) && effective?.hasAttribute("U") && visioFormulaCachedValue("0", attribute3(effective, "U")).unit !== "scalar")
+      fail2("EDIT_FORMULA_UNIT", "Paint patterns and transparency require scalar units.");
+    if (write.unit && effective?.hasAttribute("U") && visioFormulaCachedValue("0", attribute3(effective, "U")).unit !== "length")
+      fail2(
+        "EDIT_FORMULA_UNIT",
+        "Font size, paragraph indent and line weight require length units."
+      );
+    const parent = name ? rowContext.local.get(index2) : shape2;
+    const local = parent ? formattingCell(parent, name ?? write.name) : void 0;
+    if (local && attribute3(local, "F") !== "Inh" && attribute3(local, "V") === write.value && (!write.formula || attribute3(local, "F") === write.formula))
+      continue;
+    changed.set(write.name, local);
+  }
+  if (!changed.size) return false;
+  if (edit.type === "format-shape")
+    await assertShapeFormattingPaintScope(pkg, document, shape2, edit, changed, check3);
+  await assertFormattingDependencies(pkg, pagePaths, roots, edit.pageId, shape2, changed, check3);
+  for (const write of writes) {
+    check3();
+    if (!changed.has(write.name)) continue;
+    const [sectionName, index2, cellName] = write.name.split(".");
+    let parent = shape2;
+    if (cellName) {
+      const localRows = rows.get(sectionName).local;
+      let row2 = localRows.get(index2);
+      if (!row2) {
+        let section = children3(shape2, "Section").find(
+          (node) => attribute3(node, "N") === sectionName
+        );
+        if (!section) {
+          section = shape2.ownerDocument.createElementNS(shape2.namespaceURI, "Section");
+          section.setAttribute("N", sectionName);
+          shape2.insertBefore(section, children3(shape2, "Text")[0] ?? null);
+        }
+        row2 = shape2.ownerDocument.createElementNS(shape2.namespaceURI, "Row");
+        row2.setAttribute("IX", index2);
+        section.appendChild(row2);
+        localRows.set(index2, row2);
+      }
+      parent = row2;
+    }
+    let cell = formattingCell(parent, cellName ?? write.name);
+    if (!cell) {
+      cell = shape2.ownerDocument.createElementNS(shape2.namespaceURI, "Cell");
+      cell.setAttribute("N", cellName ?? write.name);
+      parent.insertBefore(
+        cell,
+        Array.from(parent.childNodes).find(
+          (node) => node.nodeType === 1 && node.localName !== "Cell"
+        ) ?? null
+      );
+    }
+    cell.setAttribute("V", write.value);
+    if (write.unit) cell.setAttribute("U", write.unit);
+    if (write.formula) cell.setAttribute("F", write.formula);
+    else if (attribute3(cell, "F") !== "No Formula") cell.removeAttribute("F");
+  }
+  return true;
+}
+
+// visio/edit-duplicate.ts
+function copyIdentity(shape2, newId, names) {
+  shape2.setAttribute("ID", newId);
+  shape2.removeAttribute("UniqueID");
+  for (const name of ["Name", "NameU"]) {
+    const value = attribute3(shape2, name);
+    if (value === void 0) continue;
+    const occupied = names.get(name);
+    let next = `${value.replace(/\.\d+$/, "")}.${newId}`;
+    if (occupied.has(next.toLowerCase())) next = `Sheet.${newId}`;
+    if (occupied.has(next.toLowerCase()))
+      fail2("UNSUPPORTED_DUPLICATE", "Duplicated default shape name is already occupied.");
+    if (next.length > 4096)
+      fail2("UNSUPPORTED_DUPLICATE", "Duplicated name exceeds metadata limits.");
+    shape2.setAttribute(name, next);
+    occupied.add(next.toLowerCase());
+  }
+}
+async function duplicateVisioShapes(pkg, pagePaths, roots, document, edit, check3, detached) {
+  const root = roots.get(edit.pageId);
+  if (!root) fail2("EDIT_TARGET_NOT_FOUND", "Page does not exist.");
+  const ids = /* @__PURE__ */ new Set();
+  for (const node of Array.from(root.getElementsByTagName("*")))
+    if (node.localName === "Shape" && node.namespaceURI === root.namespaceURI) {
+      const id = attribute3(node, "ID");
+      if (!id || ids.has(id)) fail2("INVALID_SHAPE_ID", "Source shape IDs must be unique.");
+      ids.add(id);
+    }
+  const newIds = new Set(edit.copies.map((copy2) => copy2.newShapeId));
+  if ([...newIds].some((id) => ids.has(id)))
+    fail2("INVALID_SHAPE_ID", "Duplicate shape ID already exists.");
+  await assertDuplicateScope(pkg, pagePaths, root, newIds, check3);
+  const sourceRoot = detached?.root ?? root;
+  const sourcePageId = detached?.pageId ?? edit.pageId;
+  const indexed = indexCells(detached ? /* @__PURE__ */ new Map([[sourcePageId, sourceRoot]]) : roots, { check: check3 });
+  const evaluate = createVisioCellEvaluator(indexed, { check: check3 }, true);
+  const containers = children3(root, "Shapes");
+  if (containers.length > 1) fail2("INVALID_SHAPE_ID", "Duplicate Shapes containers.");
+  const container = containers[0] ?? root.ownerDocument.createElementNS(root.namespaceURI, "Shapes");
+  const mapping = new Map(edit.copies.map((copy2) => [copy2.shapeId, copy2.newShapeId]));
+  const names = new Map(["Name", "NameU"].map((name) => [name, /* @__PURE__ */ new Set()]));
+  for (const node of Array.from(root.getElementsByTagName("*")))
+    if (node.localName === "Shape")
+      for (const [name, occupied] of names) {
+        const value = attribute3(node, name);
+        if (value !== void 0) occupied.add(value.toLowerCase());
+      }
+  const plans = [];
+  let cloneNodes = 0, cloneCharacters = buildXml(root).length;
+  for (const copy2 of edit.copies) {
+    check3();
+    const source2 = admitted(sourceRoot, copy2.shapeId);
+    assertCloneLeaf(source2);
+    assertUnlayeredShape(source2, document);
+    assertShapeLocks(source2, document, ["LockSelect"]);
+    for (const connects of children3(sourceRoot, "Connects"))
+      for (const connection of children3(connects, "Connect"))
+        if (["FromSheet", "ToSheet"].some((name) => attribute3(connection, name) === copy2.shapeId))
+          fail2("UNSUPPORTED_DUPLICATE", "Glued shapes cannot be duplicated safely.");
+    const x = numeric4(formattingCell(source2, "PinX")), y = numeric4(formattingCell(source2, "PinY"));
+    for (const [name, offset2] of [
+      ["PinX", edit.offsetX],
+      ["PinY", edit.offsetY]
+    ]) {
+      if (offset2 !== 0) assertEditableFormattingCell(formattingCell(source2, name));
+      evaluate(key({ pageId: sourcePageId, shapeId: copy2.shapeId, cell: name }));
+    }
+    if (Math.abs(x + edit.offsetX) > 1e6 || Math.abs(y + edit.offsetY) > 1e6)
+      fail2("UNSUPPORTED_DUPLICATE", "Duplicated pins exceed coordinate limits.");
+    cloneNodes += source2.getElementsByTagName("*").length + 1;
+    cloneCharacters += buildXml(source2).length;
+    if (cloneNodes > 1e5 || cloneCharacters > 16 * 1024 * 1024)
+      fail2("LIMIT_DUPLICATE", "Duplicated XML exceeds bounded expansion limits.");
+    plans.push({ source: source2, id: copy2.newShapeId, x: x + edit.offsetX, y: y + edit.offsetY });
+  }
+  const order = new Map(
+    children3(children3(sourceRoot, "Shapes")[0], "Shape").map((source2, index2) => [source2, index2])
+  );
+  plans.sort((a2, b) => order.get(a2.source) - order.get(b.source));
+  if (!container.parentNode) root.insertBefore(container, children3(root, "Connects")[0] ?? null);
+  const changed = [];
+  for (const plan of plans) {
+    check3();
+    const shape2 = root.ownerDocument.importNode(plan.source, true);
+    copyIdentity(shape2, plan.id, names);
+    for (const node of [shape2, ...Array.from(shape2.getElementsByTagName("*"))]) {
+      const source2 = executableCellFormula(attribute3(node, "F"));
+      if (!source2) continue;
+      const analysis = analyzeVisioFormula(source2);
+      if (analysis.references.some((ref) => ref.shapeId !== void 0 && mapping.has(ref.shapeId)))
+        node.setAttribute(
+          "F",
+          mapVisioFormulaSyntax(
+            source2,
+            (segment) => segment.replace(
+              /\bSheet\.(\d+)!/gi,
+              (match2, id) => mapping.has(id) ? `Sheet.${mapping.get(id)}!` : match2
+            )
+          )
+        );
+    }
+    for (const [name, value, offset2] of [
+      ["PinX", plan.x, edit.offsetX],
+      ["PinY", plan.y, edit.offsetY]
+    ])
+      if (offset2 !== 0) {
+        setCell(shape2, name, value);
+        changed.push({ pageId: edit.pageId, shapeId: plan.id, cell: name });
+      }
+    container.appendChild(shape2);
+  }
+  if (changed.length) {
+    await assertGeometryPackageScope(
+      pkg,
+      pagePaths,
+      plans.map((plan) => ({
+        type: "move-shape",
+        pageId: edit.pageId,
+        shapeId: plan.id,
+        x: plan.x,
+        y: plan.y
+      })),
+      check3,
+      roots
+    );
+    const depends = createVisioDependencyQuery(roots, { check: check3 });
+    for (const plan of plans) {
+      const clone = children3(container, "Shape").find((node) => attribute3(node, "ID") === plan.id);
+      for (const section of children3(clone, "Section"))
+        if (attribute3(section, "N") === "Field")
+          for (const row2 of children3(section, "Row"))
+            for (const cell of children3(row2, "Cell")) {
+              check3();
+              const name = `Field.${attribute3(row2, "N") ?? attribute3(row2, "IX") ?? "0"}.${attribute3(cell, "N") ?? ""}`;
+              if (depends({ pageId: edit.pageId, shapeId: plan.id, cell: name }, changed))
+                fail2(
+                  "UNSUPPORTED_DUPLICATE",
+                  "Pin-dependent text fields need native display-cache regeneration."
+                );
+            }
+    }
+  }
+  const dirty = /* @__PURE__ */ new Set([edit.pageId]);
+  for (const id of recalculateVisioCells(roots, changed, { check: check3 })) dirty.add(id);
+  return [...dirty];
+}
+function assertCloneLeaf(source2) {
+  if (Array.from(source2.getElementsByTagName("*")).some(
+    (node) => node.localName === "Shape" && (node.namespaceURI === VISIO_NS || node.namespaceURI === VISIO_LEGACY_NS)
+  ))
+    fail2("UNSUPPORTED_DUPLICATE", "Nested Visio shape identities cannot be copied as leaf XML.");
+}
+
+// visio/clipboard-resources.ts
+async function clipboardResources(pkg) {
+  const path2 = await related(pkg, "", "document");
+  if (path2 !== "visio/document.xml")
+    fail2("UNSUPPORTED_CLIPBOARD", "Clipboard requires the conventional document part.");
+  const document = (await visioXml(pkg, path2, "VisioDocument")).cloneNode(true);
+  for (const node of Array.from(document.childNodes))
+    if (node.nodeType !== 1 || !["Colors", "FaceNames", "StyleSheets", "DocumentSheet"].includes(node.localName))
+      document.removeChild(node);
+  const resources = [{ path: path2, xml: buildXml(document) }];
+  const relationships = (await pkg.readXml("visio/_rels/document.xml.rels")).cloneNode(
+    true
+  );
+  for (const node of Array.from(relationships.childNodes))
+    if (node.nodeType !== 1 || !(attribute3(node, "Type") ?? "").endsWith("/theme"))
+      relationships.removeChild(node);
+  resources.push({ path: "visio/_rels/document.xml.rels", xml: buildXml(relationships) });
+  for (const name of pkg.paths().sort())
+    if (/^visio\/theme\/(?:[^/]+\.xml|_rels\/[^/]+\.rels)$/.test(name))
+      resources.push({ path: name, xml: buildXml(await pkg.readXml(name)) });
+  return resources.sort((a2, b) => a2.path.localeCompare(b.path));
+}
+async function clipboardPageContext(pkg, pageId) {
+  const document = await related(pkg, "", "document");
+  const pagesPath = await related(pkg, document, "pages");
+  const pages = children3(await visioXml(pkg, pagesPath, "Pages"), "Page");
+  const matches2 = pages.filter((page2) => attribute3(page2, "ID") === pageId);
+  if (matches2.length !== 1) fail2("EDIT_TARGET_NOT_FOUND", "Clipboard page must exist uniquely.");
+  const page = matches2[0], sheets = children3(page, "PageSheet");
+  if (sheets.length !== 1) fail2("UNSUPPORTED_CLIPBOARD", "One explicit PageSheet is required.");
+  const scale2 = visioPageGeometryScale(
+    readSheet(sheets[0]).cells,
+    () => fail2("UNSUPPORTED_CLIPBOARD", "Page drawing ratio is unresolved.")
+  );
+  const context = page.ownerDocument.createElementNS(page.namespaceURI, "PageContext");
+  context.setAttribute("PageNumber", String(pages.indexOf(page) + 1));
+  context.setAttribute("PageCount", String(pages.length));
+  for (const name of ["Background", "BackPage"]) {
+    const value = attribute3(page, name);
+    if (value !== void 0) context.setAttribute(name, value);
+  }
+  context.appendChild(sheets[0].cloneNode(true));
+  return { xml: buildXml(context), scale: scale2 };
+}
+function assertClipboardResourceReferences(root, document) {
+  const styles = new Map(
+    children3(children3(document, "StyleSheets")[0], "StyleSheet").map((style2) => [
+      attribute3(style2, "ID"),
+      style2
+    ])
+  );
+  const fonts = children3(children3(document, "FaceNames")[0], "FaceName");
+  const fontIds = new Set(fonts.map((font2, index2) => attribute3(font2, "ID") ?? String(index2)));
+  const fontNames = new Set(
+    fonts.map((font2) => attribute3(font2, "Name") ?? attribute3(font2, "NameU"))
+  );
+  const fontById = new Map(
+    fonts.map((font2, index2) => [
+      attribute3(font2, "ID") ?? String(index2),
+      attribute3(font2, "Name") ?? attribute3(font2, "NameU")
+    ])
+  );
+  if (fontIds.size !== fonts.length || fontNames.size !== fonts.length || new Set([...fontNames].map((name) => name?.toLowerCase())).size !== fonts.length)
+    fail2(
+      "UNSUPPORTED_CLIPBOARD",
+      "Clipboard font definitions must have unique IDs and family names."
+    );
+  const pool = [root, ...Array.from(root.getElementsByTagName("*"))], included = /* @__PURE__ */ new Set();
+  const validateStyle = (id, category, seen = /* @__PURE__ */ new Set()) => {
+    if (seen.has(id) || seen.size >= 64)
+      fail2("UNSUPPORTED_CLIPBOARD", "Cyclic clipboard style ancestry.");
+    const style2 = styles.get(id);
+    if (!style2)
+      fail2("UNSUPPORTED_CLIPBOARD", "Clipboard style reference does not exist in target.");
+    if (!included.has(style2)) {
+      included.add(style2);
+      pool.push(style2, ...Array.from(style2.getElementsByTagName("*")));
+    }
+    seen.add(id);
+    const parent = attribute3(style2, category);
+    if (parent !== void 0 && parent !== id) validateStyle(parent, category, seen);
+  };
+  for (const node of pool) {
+    for (const attr3 of Array.from(node.attributes))
+      if (attr3.namespaceURI === "http://schemas.openxmlformats.org/officeDocument/2006/relationships")
+        fail2("UNSUPPORTED_CLIPBOARD", "Relationship-bearing clipboard fragments are unsupported.");
+    for (const category of ["FillStyle", "LineStyle", "TextStyle"]) {
+      const id = attribute3(node, category);
+      if (id !== void 0) validateStyle(id, category);
+    }
+    if (node.localName === "Cell" && ["Font", "BulletFont"].includes(attribute3(node, "N") ?? "")) {
+      const value = attribute3(node, "V");
+      if (value !== void 0 && value !== "Themed" && attribute3(node, "F") !== "Inh" && !fontIds.has(value) && !fontNames.has(value))
+        fail2("UNSUPPORTED_CLIPBOARD", "Clipboard font does not exist in target FaceNames.");
+      const formula = executableCellFormula(attribute3(node, "F"));
+      const ast = formula ? parseVisioFormula(formula) : void 0;
+      if (ast?.kind === "call" && ast.name === "FONT") {
+        const arg = ast.args[0];
+        if (ast.args.length !== 1 || arg?.kind !== "string" || !fontNames.has(arg.value) || value !== void 0 && (fontById.get(value) ?? value) !== arg.value)
+          fail2("UNSUPPORTED_CLIPBOARD", "Clipboard font formula and existing font cache disagree.");
+      }
+    }
+  }
+}
+
+// visio/clipboard-xml.ts
+function assertClipboardXmlLimits(snapshot, check3) {
+  let nodes = 0;
+  for (const xml of [
+    snapshot.pageContext,
+    ...snapshot.resources.map((resource) => resource.xml),
+    ...snapshot.shapes.map((shape2) => shape2.xml)
+  ]) {
+    if (nodes >= 1e5) fail2("LIMIT_CLIPBOARD", "Clipboard aggregate node limit exceeded.");
+    nodes += inspectXml(
+      xml,
+      { ...DEFAULTS2, maxXmlChars: 8 * 1024 * 1024, maxXmlNodes: 1e5 - nodes },
+      check3
+    );
+  }
+}
+function clipboardXml(xml, check3) {
+  inspectXml(xml, { ...DEFAULTS2, maxXmlChars: 8 * 1024 * 1024, maxXmlNodes: 1e5 }, check3);
+  const root = parseXml(xml).documentElement;
+  inspectNamespaces(root, check3);
+  return root;
+}
+function assertClipboardFormulaScope(root, ids, check3) {
+  for (const node of [root, ...Array.from(root.getElementsByTagName("*"))]) {
+    check3();
+    const formula = executableCellFormula(attribute3(node, "F"));
+    if (!formula) continue;
+    const analysis = analyzeVisioFormula(formula, { });
+    if (analysis.dynamic || analysis.references.some((ref) => ref.shapeId !== void 0 && !ids.has(ref.shapeId)))
+      fail2(
+        "UNSUPPORTED_CLIPBOARD",
+        "Clipboard formulas reference uncaptured shapes or dynamic lookup."
+      );
+    let pageFunction = false;
+    mapVisioFormulaSyntax(formula, (segment) => {
+      pageFunction ||= /\b(?:PAGENUMBER|PAGECOUNT|PAGES)\s*\(/i.test(segment);
+      return segment;
+    });
+    if (pageFunction)
+      fail2(
+        "UNSUPPORTED_CLIPBOARD",
+        "Page-context clipboard functions require native cache regeneration."
+      );
+  }
+}
+function clipboardShapeRoot(snapshot, check3) {
+  assertClipboardXmlLimits(snapshot, check3);
+  const parseShape2 = (shape2) => {
+    const node = clipboardXml(shape2.xml, check3);
+    if (node.localName !== "Shape" || ![VISIO_NS, VISIO_LEGACY_NS].includes(node.namespaceURI ?? "") || attribute3(node, "ID") !== shape2.shapeId)
+      fail2("INVALID_CLIPBOARD", "Clipboard XML must contain the declared Visio Shape.");
+    return node;
+  };
+  const first3 = parseShape2(snapshot.shapes[0]);
+  const root = clipboardXml(
+    `<PageContents xmlns="${first3.namespaceURI}"><Shapes/></PageContents>`,
+    check3
+  );
+  const container = root.firstChild;
+  container.appendChild(root.ownerDocument.importNode(first3, true));
+  for (let index2 = 1; index2 < snapshot.shapes.length; index2++) {
+    check3();
+    container.appendChild(
+      root.ownerDocument.importNode(parseShape2(snapshot.shapes[index2]), true)
+    );
+  }
+  if (root.getElementsByTagName("*").length > 1e5)
+    fail2("LIMIT_CLIPBOARD", "Clipboard node limit exceeded.");
+  assertClipboardFormulaScope(root, new Set(snapshot.selectionIds), check3);
+  return root;
+}
+
+// visio/edit-paste.ts
+async function pasteVisioShapes(pkg, pagePaths, roots, document, edit, check3) {
+  assertClipboardXmlLimits(edit.clipboard, check3);
+  const context = await clipboardPageContext(pkg, edit.pageId);
+  if (context.scale !== edit.clipboard.sourceDrawingScale || buildXml(clipboardXml(edit.clipboard.pageContext, check3)) !== context.xml)
+    fail2(
+      "CLIPBOARD_CONTEXT_MISMATCH",
+      "Clipboard requires matching page settings, ordinal and drawing ratio."
+    );
+  const actual = await clipboardResources(pkg);
+  if (actual.length !== edit.clipboard.resources.length || actual.some((resource, index2) => {
+    const captured = edit.clipboard.resources[index2];
+    return captured.path !== resource.path || buildXml(clipboardXml(captured.xml, check3)) !== resource.xml;
+  }))
+    fail2(
+      "CLIPBOARD_RESOURCE_MISMATCH",
+      "Clipboard font, style and theme definitions differ from target."
+    );
+  const source2 = clipboardShapeRoot(edit.clipboard, check3);
+  assertClipboardResourceReferences(source2, document);
+  return duplicateVisioShapes(
+    pkg,
+    pagePaths,
+    roots,
+    document,
+    { ...edit},
+    check3,
+    { root: source2, pageId: edit.clipboard.sourcePageId }
+  );
+}
+
+// visio/edit-delete.ts
+function deleteVisioShapes(roots, document, edits, check3) {
+  const removed = /* @__PURE__ */ new Map();
+  const shapes = [];
+  for (const edit of edits) {
+    check3();
+    const ids = removed.get(edit.pageId) ?? /* @__PURE__ */ new Set();
+    if (ids.has(edit.shapeId)) fail2("INVALID_EDIT", "A deletion target must occur only once.");
+    ids.add(edit.shapeId);
+    removed.set(edit.pageId, ids);
+    const root = roots.get(edit.pageId);
+    if (!root) fail2("EDIT_TARGET_NOT_FOUND", "Page does not exist.");
+    const shape2 = admitted(root, edit.shapeId, void 0, void 0, "delete");
+    if (Array.from(shape2.getElementsByTagName("*")).some(
+      (node) => (node.namespaceURI === VISIO_NS || node.namespaceURI === VISIO_LEGACY_NS) && node.localName === "Shape"
+    ))
+      fail2(
+        "UNSUPPORTED_GEOMETRY_EDIT",
+        "Nested shape identities cannot be removed as a local leaf."
+      );
+    protectedShape(shape2, document);
+    if (numeric4(cells(shape2).get("LockDelete"), 0) !== 0)
+      fail2("EDIT_PROTECTED_CELL", "LockDelete prevents this operation.");
+    shapes.push(shape2);
+  }
+  assertVisioShapesUnreferenced(roots, removed, { check: check3 });
+  check3();
+  for (const shape2 of shapes) shape2.parentNode.removeChild(shape2);
+  return [...removed.keys()];
+}
+
 // visio/edit.ts
 function positive3(value) {
   if (!Number.isSafeInteger(value) || value <= 0)
@@ -47777,26 +49590,50 @@ async function editVsdx(input, edits, options = {}) {
   }
   const dirty = /* @__PURE__ */ new Map();
   const roots = /* @__PURE__ */ new Map();
-  const geometry = commands.some((command2) => command2.type !== "replace-plain-text");
+  const geometryCommands = commands.filter(
+    (command2) => command2.type !== "replace-plain-text" && command2.type !== "reorder-shape" && command2.type !== "duplicate-shapes" && command2.type !== "paste-shapes" && !isVisioFormatEdit(command2)
+  );
   let document;
   let masterMovePins = emptyMasterMoveProof();
-  if (geometry) {
+  if (geometryCommands.length || commands.some(
+    (command2) => command2.type === "replace-plain-text" || isVisioFormatEdit(command2) || command2.type === "reorder-shape" || command2.type === "duplicate-shapes" || command2.type === "paste-shapes"
+  )) {
     for (const [pageId, path3] of pages) {
       const sourceRoot = await visioXml(pkg, path3, "PageContents");
       roots.set(pageId, sourceRoot.ownerDocument.cloneNode(true).documentElement);
     }
-    masterMovePins = await assertGeometryPackageScope(
-      pkg,
-      new Set(pages.values()),
-      commands.filter((command2) => command2.type !== "replace-plain-text"),
-      check3,
-      roots
-    );
+    for (const [pageId, root] of roots) {
+      const ids = new Set(
+        geometryCommands.filter((command2) => command2.type === "create-text-box" && command2.pageId === pageId).map((command2) => command2.shapeId)
+      );
+      if (ids.size) await assertDuplicateScope(pkg, new Set(pages.values()), root, ids, check3);
+    }
+    if (geometryCommands.length)
+      masterMovePins = await assertGeometryPackageScope(
+        pkg,
+        new Set(pages.values()),
+        geometryCommands,
+        check3,
+        roots
+      );
     const path2 = await related(pkg, "", "document");
     document = await visioXml(pkg, path2, "VisioDocument");
   }
   let textChanged = false;
-  for (const command2 of commands) {
+  if (commands.some((command2) => command2.type === "reorder-shape"))
+    await assertShapeOrderPackageScope(pkg, check3);
+  let formatChanged = false;
+  let orderChanged = false;
+  let duplicateChanged = false;
+  let pasteChanged = false;
+  const deletions = commands.filter(
+    (command2) => command2.type === "delete-shape"
+  );
+  const deleteOnly = deletions.length > 0 && deletions.length === commands.length;
+  if (deleteOnly)
+    for (const pageId of deleteVisioShapes(roots, document, deletions, check3))
+      dirty.set(pages.get(pageId), roots.get(pageId));
+  for (const command2 of deleteOnly ? [] : commands) {
     check3();
     const path2 = pages.get(command2.pageId);
     if (!path2) fail2("EDIT_TARGET_NOT_FOUND", "Page does not exist.");
@@ -47807,10 +49644,42 @@ async function editVsdx(input, edits, options = {}) {
       roots.set(command2.pageId, root);
     }
     if (command2.type === "replace-plain-text") {
-      if (replacePlainText(root, command2.shapeId, command2.text, check3)) {
+      if (await replaceScopedPlainText(pkg, new Set(pages.values()), roots, document, command2, check3)) {
         dirty.set(path2, root);
         textChanged = true;
       }
+    } else if (isVisioFormatEdit(command2)) {
+      if (await applyFormattingEdit(pkg, new Set(pages.values()), roots, document, command2, check3)) {
+        dirty.set(path2, root);
+        formatChanged = true;
+      }
+    } else if (command2.type === "reorder-shape") {
+      if (reorderVisioShape(root, document, command2, check3)) {
+        dirty.set(path2, root);
+        orderChanged = true;
+      }
+    } else if (command2.type === "paste-shapes") {
+      for (const pageId of await pasteVisioShapes(
+        pkg,
+        new Set(pages.values()),
+        roots,
+        document,
+        command2,
+        check3
+      ))
+        dirty.set(pages.get(pageId), roots.get(pageId));
+      pasteChanged = true;
+    } else if (command2.type === "duplicate-shapes") {
+      for (const pageId of await duplicateVisioShapes(
+        pkg,
+        new Set(pages.values()),
+        roots,
+        document,
+        command2,
+        check3
+      ))
+        dirty.set(pages.get(pageId), roots.get(pageId));
+      duplicateChanged = true;
     } else {
       for (const pageId of applyGeometryEdit(roots, document, command2, check3, masterMovePins))
         dirty.set(pages.get(pageId), roots.get(pageId));
@@ -47845,17 +49714,50 @@ async function editVsdx(input, edits, options = {}) {
   return {
     bytes,
     changedParts: [...dirty.keys()],
-    diagnostics: dirty.size && textChanged ? [
-      {
-        code: "edit-caches-not-recalculated",
-        message: "Text was replaced without recalculating formulas or dependent caches. Native Visio reopen and rendering compatibility are unverified."
-      }
-    ] : dirty.size ? [
-      {
-        code: "edit-geometry-experimental",
-        message: "Supported affected geometry caches were recalculated. Native Visio reopen and rendering fidelity remain unverified."
-      }
-    ] : []
+    diagnostics: [
+      ...pasteChanged ? [
+        {
+          code: "edit-paste-experimental",
+          message: "Captured shape XML was pasted with compatible resources and page context. Clipboard placement and cross-document fidelity are limited to supported cases."
+        }
+      ] : [],
+      ...duplicateChanged ? [
+        {
+          code: "edit-duplicate-experimental",
+          message: "Local shape XML was copied and supported pin-dependent caches were recalculated. Native fidelity is limited to tested cases."
+        }
+      ] : [],
+      ...dirty.size && textChanged ? [
+        {
+          code: "edit-caches-not-recalculated",
+          message: "Plain text changed; affected or unknown formula dependencies were refused. Untouched caches were preserved. Native fidelity is limited to tested cases."
+        }
+      ] : [],
+      ...dirty.size && deleteOnly ? [
+        {
+          code: "edit-delete-experimental",
+          message: "Reference-closed local shapes were deleted. Retained formulas and caches were preserved; glue healing and inherited shape deletion remain unsupported."
+        }
+      ] : [],
+      ...dirty.size && geometryCommands.length && !deleteOnly ? [
+        {
+          code: "edit-geometry-experimental",
+          message: "Supported affected geometry caches were recalculated. Native Visio reopen and rendering fidelity remain unverified."
+        }
+      ] : [],
+      ...formatChanged ? [
+        {
+          code: "edit-formatting-experimental",
+          message: "Text and solid shape formatting was changed without recalculating text layout. Native Visio reopen and rendering fidelity remain unverified."
+        }
+      ] : [],
+      ...orderChanged ? [
+        {
+          code: "edit-shape-order-experimental",
+          message: "Local sibling shape order was changed. Native Visio reopen and rendering fidelity remain unverified."
+        }
+      ] : []
+    ]
   };
 }