ooxml-core 1.2.0 → 1.3.0

package/dist/automation/index.mjs

@@ -253,14 +253,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;
   }
@@ -2231,12 +2231,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 = [
@@ -4564,10 +4564,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))}`,
@@ -8618,9 +8618,9 @@ function rejectUnsafeRunSegmentation(paragraph2, base, oldRuns) {
     (run2) => !run2.image && !run2.equation && (run2.restoredRunPropertiesXml || run2.sourceRunPropertiesXml)
   ))
     return;
-  const sameText = paragraph2.runs.map((run2) => run2.text).join("") === base.runs.map((run2) => run2.text).join("");
+  const sameText2 = paragraph2.runs.map((run2) => run2.text).join("") === base.runs.map((run2) => run2.text).join("");
   const sameBoundaries = paragraph2.runs.length === base.runs.length && paragraph2.runs.every((run2, index2) => run2.text === base.runs[index2]?.text);
-  if (sameBoundaries || !sameText && paragraph2.runs.length === base.runs.length) return;
+  if (sameBoundaries || !sameText2 && paragraph2.runs.length === base.runs.length) return;
   throw new Error(
     `Cannot edit paragraph ${paragraph2.id}: changing run boundaries could drop unsupported run properties. The original DOCX package remains unchanged.`
   );
@@ -11971,10 +11971,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];
@@ -12492,7 +12492,7 @@ var NAME_RE = /^[A-Za-z_\\\u00A1-\uFFFF][A-Za-z0-9_.?\\\u00A1-\uFFFF]*/;
 var CELL_RE = /^(\$?)([A-Za-z]{1,3})(\$?)(\d{1,7})/;
 var COLS_RE = /^(\$?)([A-Za-z]{1,3}):(\$?)([A-Za-z]{1,3})/;
 var ROWS_RE = /^(\$?)(\d{1,7}):(\$?)(\d{1,7})/;
-var NUMBER_RE = /^(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/;
+var NUMBER_RE = /^(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?/;
 var sticky = (re) => new RegExp(re.source.replace(/^\^/, ""), "y");
 var CELL_AT = sticky(CELL_RE);
 var COLS_AT = sticky(COLS_RE);
@@ -12652,14 +12652,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 === "[") {
@@ -12668,13 +12667,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);
@@ -12839,7 +12848,7 @@ function readName(source2, at2, start, prefix) {
 }
 var joinTokens = (tokens3) => tokens3.map((t) => t.text).join("");
 
-// xlsx/formula/transform.ts
+// xlsx/formula/ref-text.ts
 function safeTokens(formula) {
   try {
     return tokenize(formula);
@@ -12858,50 +12867,26 @@ function formatRefSpec(spec2) {
   if (spec2.kind === "cell") return a2;
   return `${a2}:${cornerText(spec2.end, spec2.kind)}`;
 }
-function rewrite(token, ref) {
+function rewriteRef(token, ref) {
   const prefix = token.prefix?.text ?? "";
   if (!ref) return `${prefix}#REF!`;
   return `${prefix}${formatRefSpec(ref)}${token.spill ? "#" : ""}`;
 }
 var sameSpec = (a2, b) => a2.kind === b.kind && a2.start.row === b.start.row && a2.start.col === b.start.col && a2.end.row === b.end.row && a2.end.col === b.end.col;
-function translateFormula(formula, dRow, dCol) {
-  const tokens3 = safeTokens(formula);
-  if (!tokens3) return formula;
-  for (const token of tokens3) {
-    if (token.kind !== "ref" || !token.ref) continue;
-    const spec2 = token.ref;
-    const move = (c2) => {
-      const row2 = spec2.kind === "cols" || c2.rowAbs ? c2.row : c2.row + dRow;
-      const col = spec2.kind === "rows" || c2.colAbs ? c2.col : c2.col + dCol;
-      if (row2 < 0 || row2 > MAX_ROW || col < 0 || col > MAX_COL) return void 0;
-      return { ...c2, row: row2, col };
-    };
-    const start = move(spec2.start);
-    const end = move(spec2.end);
-    const next = start && end ? { kind: spec2.kind, start, end } : void 0;
-    if (next && sameSpec(next, spec2)) continue;
-    token.text = rewrite(token, next);
-  }
-  return joinTokens(tokens3);
+var needsQuote = (name) => !/^[A-Za-z_¡-￿][A-Za-z0-9_.¡-￿]*$/.test(name) || /^[A-Za-z]{1,3}\d+$/.test(name) || /^(?:R\d*C?\d*|C\d*)$/i.test(name) || /^(?:TRUE|FALSE)$/i.test(name);
+function prefixText(prefix) {
+  const sheets = prefix.sheet2 !== void 0 ? `${prefix.sheet}:${prefix.sheet2}` : prefix.sheet;
+  const book = prefix.book !== void 0 ? `[${prefix.book}]` : "";
+  const quote2 = needsQuote(prefix.sheet) || prefix.sheet2 !== void 0 && needsQuote(prefix.sheet2);
+  return quote2 ? `'${(book + sheets).replace(/'/g, "''")}'!` : `${book}${sheets}!`;
 }
-var sheetMatches = (prefix, formulaSheet, sheet) => {
-  if (prefix?.book !== void 0) return false;
-  const name = prefix ? prefix.sheet : formulaSheet;
-  return name.toLowerCase() === sheet.toLowerCase();
-};
-function shiftInterval(a2, b, at2, count2, max) {
-  if (count2 > 0) {
-    const na2 = a2 >= at2 ? a2 + count2 : a2;
-    const nb2 = b >= at2 ? b + count2 : b;
-    if (nb2 > max) return na2 > max ? void 0 : [na2, max];
-    return [na2, nb2];
-  }
-  const n = -count2;
-  const last = at2 + n - 1;
-  if (a2 >= at2 && b <= last) return void 0;
-  const na = a2 < at2 ? a2 : a2 <= last ? at2 : a2 - n;
-  const nb = b < at2 ? b : b <= last ? at2 - 1 : b - n;
-  return [na, nb];
+
+// xlsx/formula/shift-formula.ts
+var templates = /* @__PURE__ */ new Map();
+var MAX_TEMPLATES = 2e5;
+function remember2(text2, template) {
+  if (templates.size >= MAX_TEMPLATES) templates.clear();
+  templates.set(text2, template);
 }
 function mergeSpacedAreas(tokens3) {
   const out = [];
@@ -12928,63 +12913,145 @@ function mergeSpacedAreas(tokens3) {
   }
   return out;
 }
-function shiftFormula(formula, formulaSheet, spec2) {
-  if (spec2.count === 0) return formula;
+function templateOf(formula) {
+  const cached3 = templates.get(formula);
+  if (cached3 !== void 0) return cached3;
   const raw2 = safeTokens(formula);
-  if (!raw2) return formula;
-  const tokens3 = mergeSpacedAreas(raw2);
-  const isRow = spec2.axis === "row";
-  for (const token of tokens3) {
-    if (token.kind !== "ref" || !token.ref || !sheetMatches(token.prefix, formulaSheet, spec2.sheet))
-      continue;
-    const ref = token.ref;
-    if (isRow && ref.kind === "cols" || !isRow && ref.kind === "rows") continue;
-    const startFirst = isRow ? ref.start.row <= ref.end.row : ref.start.col <= ref.end.col;
-    const lo = startFirst ? ref.start : ref.end;
-    const hi = startFirst ? ref.end : ref.start;
-    const shifted2 = shiftInterval(
-      isRow ? lo.row : lo.col,
-      isRow ? hi.row : hi.col,
-      spec2.at,
-      spec2.count,
-      isRow ? MAX_ROW : MAX_COL
-    );
-    let next;
-    if (shifted2) {
-      const [a2, b] = shifted2;
-      const nlo = isRow ? { ...lo, row: a2 } : { ...lo, col: a2 };
-      const nhi = isRow ? { ...hi, row: b } : { ...hi, col: b };
-      next = { kind: ref.kind, start: startFirst ? nlo : nhi, end: startFirst ? nhi : nlo };
-      if (ref.kind === "cell") next.end = next.start;
+  let template = null;
+  if (raw2) {
+    template = [];
+    let literal2 = "";
+    for (const token of mergeSpacedAreas(raw2)) {
+      if (token.kind !== "ref" && !(token.kind === "name" && token.prefix)) {
+        literal2 += token.text;
+        continue;
+      }
+      if (literal2) template.push(literal2);
+      literal2 = "";
+      const part = { kind: token.kind, text: token.text };
+      if (token.prefix) {
+        part.prefix = token.prefix;
+        if (token.prefix.book === void 0) part.sheet = token.prefix.sheet.toLowerCase();
+      }
+      if (token.ref) part.ref = token.ref;
+      if (token.spill) part.spill = true;
+      template.push(part);
     }
-    if (next && sameSpec(next, ref)) continue;
-    token.text = rewrite(token, next);
+    if (literal2) template.push(literal2);
   }
-  return joinTokens(tokens3);
+  remember2(formula, template);
+  return template;
 }
-var needsQuote = (name) => !/^[A-Za-z_\u00A1-\uFFFF][A-Za-z0-9_.\u00A1-\uFFFF]*$/.test(name) || /^[A-Za-z]{1,3}\d+$/.test(name) || /^(?:R\d*C?\d*|C\d*)$/i.test(name) || /^(?:TRUE|FALSE)$/i.test(name);
-function prefixText(prefix) {
-  const sheets = prefix.sheet2 !== void 0 ? `${prefix.sheet}:${prefix.sheet2}` : prefix.sheet;
-  const book = prefix.book !== void 0 ? `[${prefix.book}]` : "";
-  const quote2 = needsQuote(prefix.sheet) || prefix.sheet2 !== void 0 && needsQuote(prefix.sheet2);
-  return quote2 ? `'${(book + sheets).replace(/'/g, "''")}'!` : `${book}${sheets}!`;
+function rewriteTemplate(formula, rewrite2) {
+  const template = templateOf(formula);
+  if (!template) return formula;
+  let next;
+  for (let i2 = 0; i2 < template.length; i2++) {
+    const part = template[i2];
+    if (typeof part === "string") continue;
+    const changed = rewrite2(part);
+    if (!changed) continue;
+    next ??= template.slice();
+    next[i2] = changed;
+  }
+  if (!next) return formula;
+  const text2 = next.map((part) => typeof part === "string" ? part : part.text).join("");
+  remember2(text2, next);
+  return text2;
+}
+function shiftInterval(a2, b, at2, count2, max) {
+  if (count2 > 0) {
+    const na2 = a2 >= at2 ? a2 + count2 : a2;
+    const nb2 = b >= at2 ? b + count2 : b;
+    if (nb2 > max) return na2 > max ? void 0 : [na2, max];
+    return [na2, nb2];
+  }
+  const n = -count2;
+  const last = at2 + n - 1;
+  if (a2 >= at2 && b <= last) return void 0;
+  const na = a2 < at2 ? a2 : a2 <= last ? at2 : a2 - n;
+  const nb = b < at2 ? b : b <= last ? at2 - 1 : b - n;
+  return [na, nb];
+}
+function shiftRef(ref, spec2) {
+  const isRow = spec2.axis === "row";
+  if (isRow && ref.kind === "cols" || !isRow && ref.kind === "rows") return ref;
+  const startFirst = isRow ? ref.start.row <= ref.end.row : ref.start.col <= ref.end.col;
+  const lo = startFirst ? ref.start : ref.end;
+  const hi = startFirst ? ref.end : ref.start;
+  const shifted2 = shiftInterval(
+    isRow ? lo.row : lo.col,
+    isRow ? hi.row : hi.col,
+    spec2.at,
+    spec2.count,
+    isRow ? MAX_ROW : MAX_COL
+  );
+  if (!shifted2) return void 0;
+  const [a2, b] = shifted2;
+  const nlo = isRow ? { ...lo, row: a2 } : { ...lo, col: a2 };
+  const nhi = isRow ? { ...hi, row: b } : { ...hi, col: b };
+  const next = {
+    kind: ref.kind,
+    start: startFirst ? nlo : nhi,
+    end: startFirst ? nhi : nlo
+  };
+  if (ref.kind === "cell") next.end = next.start;
+  return sameSpec(next, ref) ? ref : next;
+}
+function shiftFormula(formula, formulaSheet, spec2) {
+  if (spec2.count === 0) return formula;
+  const sheet = spec2.sheet.toLowerCase();
+  const own = formulaSheet.toLowerCase() === sheet;
+  return rewriteTemplate(formula, (part) => {
+    if (part.kind !== "ref" || !part.ref || (part.prefix ? part.sheet !== sheet : !own))
+      return void 0;
+    const next = shiftRef(part.ref, spec2);
+    if (next === part.ref) return void 0;
+    const out = { kind: "ref", text: rewriteRef(part, next) };
+    if (part.prefix) out.prefix = part.prefix;
+    if (part.sheet !== void 0) out.sheet = part.sheet;
+    if (next) out.ref = next;
+    if (part.spill) out.spill = true;
+    return out;
+  });
 }
 function renameSheetInFormula(formula, oldName, newName) {
-  const tokens3 = safeTokens(formula);
-  if (!tokens3) return formula;
   const lower2 = oldName.toLowerCase();
-  for (const token of tokens3) {
-    const prefix = token.prefix;
-    if (!prefix || prefix.book !== void 0) continue;
-    const first3 = prefix.sheet.toLowerCase() === lower2;
+  return rewriteTemplate(formula, (part) => {
+    const prefix = part.prefix;
+    if (!prefix || part.sheet === void 0) return void 0;
+    const first3 = part.sheet === lower2;
     const second = prefix.sheet2?.toLowerCase() === lower2;
-    if (!first3 && !second) continue;
+    if (!first3 && !second) return void 0;
     const renamed = { ...prefix, sheet: first3 ? newName : prefix.sheet };
     if (prefix.sheet2 !== void 0) renamed.sheet2 = second ? newName : prefix.sheet2;
     const text2 = prefixText(renamed);
-    token.text = text2 + token.text.slice(prefix.text.length);
     renamed.text = text2;
-    token.prefix = renamed;
+    const out = { ...part, text: text2 + part.text.slice(prefix.text.length) };
+    out.prefix = renamed;
+    out.sheet = renamed.sheet.toLowerCase();
+    return out;
+  });
+}
+
+// xlsx/formula/transform.ts
+function translateFormula(formula, dRow, dCol) {
+  const tokens3 = safeTokens(formula);
+  if (!tokens3) return formula;
+  for (const token of tokens3) {
+    if (token.kind !== "ref" || !token.ref) continue;
+    const spec2 = token.ref;
+    const move = (c2) => {
+      const row2 = spec2.kind === "cols" || c2.rowAbs ? c2.row : c2.row + dRow;
+      const col = spec2.kind === "rows" || c2.colAbs ? c2.col : c2.col + dCol;
+      if (row2 < 0 || row2 > MAX_ROW || col < 0 || col > MAX_COL) return void 0;
+      return { ...c2, row: row2, col };
+    };
+    const start = move(spec2.start);
+    const end = move(spec2.end);
+    const next = start && end ? { kind: spec2.kind, start, end } : void 0;
+    if (next && sameSpec(next, spec2)) continue;
+    token.text = rewriteRef(token, next);
   }
   return joinTokens(tokens3);
 }
@@ -13054,14 +13121,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;
   }
@@ -13073,7 +13140,7 @@ var FUTURE_FUNCTIONS = new Set(
   "AGGREGATE BETA.DIST BETA.INV BINOM.DIST BINOM.INV CEILING.PRECISE CHISQ.DIST CHISQ.DIST.RT CHISQ.INV CHISQ.INV.RT CHISQ.TEST CONFIDENCE.NORM CONFIDENCE.T COVARIANCE.P COVARIANCE.S ERF.PRECISE ERFC.PRECISE EXPON.DIST F.DIST F.DIST.RT F.INV F.INV.RT F.TEST FLOOR.PRECISE GAMMA.DIST GAMMA.INV GAMMALN.PRECISE HYPGEOM.DIST LOGNORM.DIST LOGNORM.INV MODE.MULT MODE.SNGL NEGBINOM.DIST NETWORKDAYS.INTL NORM.DIST NORM.INV NORM.S.DIST NORM.S.INV PERCENTILE.EXC PERCENTILE.INC PERCENTRANK.EXC PERCENTRANK.INC POISSON.DIST QUARTILE.EXC QUARTILE.INC RANK.AVG RANK.EQ STDEV.P STDEV.S T.DIST T.DIST.2T T.DIST.RT T.INV T.INV.2T T.TEST VAR.P VAR.S WEIBULL.DIST WORKDAY.INTL ACOT ACOTH ARABIC BASE BINOM.DIST.RANGE BITAND BITLSHIFT BITOR BITRSHIFT BITXOR CEILING.MATH COMBINA COT COTH CSC CSCH DAYS DECIMAL ENCODEURL FILTERXML FLOOR.MATH FORMULATEXT GAMMA GAUSS IFNA IMCOSH IMCOT IMCSC IMCSCH IMSEC IMSECH IMSINH IMTAN ISFORMULA ISOWEEKNUM MUNIT NUMBERVALUE PDURATION PERMUTATIONA PHI RRI SEC SECH SHEET SHEETS SKEW.P UNICHAR UNICODE WEBSERVICE XOR CONCAT FORECAST.ETS FORECAST.ETS.CONFINT FORECAST.ETS.SEASONALITY FORECAST.ETS.STAT FORECAST.LINEAR IFS MAXIFS MINIFS SWITCH TEXTJOIN XLOOKUP XMATCH FILTER SORT SORTBY UNIQUE SEQUENCE RANDARRAY LET LAMBDA TEXTBEFORE TEXTAFTER TEXTSPLIT VSTACK HSTACK TAKE DROP CHOOSEROWS CHOOSECOLS TOCOL TOROW WRAPROWS WRAPCOLS EXPAND ARRAYTOTEXT VALUETOTEXT ISOMITTED BYROW BYCOL MAP REDUCE SCAN MAKEARRAY IMAGE GROUPBY PIVOTBY PERCENTOF REGEXTEST REGEXEXTRACT REGEXREPLACE TRIMRANGE ANCHORARRAY SINGLE STOCKHISTORY FIELDVALUE".split(" ")
 );
 var WORKSHEET_PREFIXED = /* @__PURE__ */ new Set(["FILTER", "SORT"]);
-function rewrite2(formula, visit2) {
+function rewrite(formula, visit2) {
   const out = [];
   let i2 = 0;
   while (i2 < formula.length) {
@@ -13116,7 +13183,7 @@ function rewrite2(formula, visit2) {
 }
 function stripFuturePrefixes(formula) {
   if (!formula.includes("_xl")) return formula;
-  const plain2 = rewrite2(formula, (token, next, out) => {
+  const plain2 = rewrite(formula, (token, next, out) => {
     if (!next.startsWith("(")) return false;
     const stripped = token.replace(/^(_xlfn\.)?(_xlws\.)?/i, "");
     if (stripped === token) return false;
@@ -13126,7 +13193,7 @@ function stripFuturePrefixes(formula) {
   return fromStoredSyntax(plain2);
 }
 function addFuturePrefixes(formula) {
-  return rewrite2(toStoredSyntax(formula), (token, next, out) => {
+  return rewrite(toStoredSyntax(formula), (token, next, out) => {
     if (!next.startsWith("(")) return false;
     const upper2 = token.toUpperCase();
     if (!FUTURE_FUNCTIONS.has(upper2)) return false;
@@ -13779,13 +13846,13 @@ function dataBarLengths(rule2, node) {
     maxLength: rule2.maxLength ?? numAttr(bar, "maxLength") ?? 90
   };
 }
-function rewriteConditionalExtension(rule2, rewrite3) {
+function rewriteConditionalExtension(rule2, rewrite2) {
   if (!rule2.extensionXml) return;
   const doc = parseXml(rule2.extensionXml);
   let changed = false;
   for (const formula of descendants3(doc.documentElement, "f", XM)) {
     const before = formula.textContent ?? "";
-    const next = rewrite3(before);
+    const next = rewrite2(before);
     if (before !== next) {
       formula.textContent = next;
       changed = true;
@@ -14409,12 +14476,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
@@ -14957,10 +15024,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)) }));
 }
@@ -17018,7 +17085,9 @@ var PREC_INTERSECT = 9;
 var PREC_RANGE = 10;
 var OPERAND_START = /* @__PURE__ */ new Set(["ref", "name", "func", "open", "structured"]);
 function parseFormula(formula) {
-  const all2 = tokenize(formula);
+  return parseTokens(tokenize(formula));
+}
+function parseTokens(all2) {
   const tokens3 = [];
   const wsBefore = [];
   let sawWs = false;
@@ -17359,6 +17428,222 @@ function localDateToSerial(date, date1904 = date1904Mode) {
   return base + (utc - dayStart) / DAY_MS2;
 }
 
+// xlsx/formula/area-index.ts
+var BUCKET_WIDTH = 64;
+var CHUNK_SHIFT = 6;
+var CHUNKS = 64;
+function push(map, key2, value) {
+  const list = map.get(key2);
+  if (list) list.push(value);
+  else map.set(key2, [value]);
+}
+function inner(map, sheet) {
+  let found = map.get(sheet);
+  if (!found) map.set(sheet, found = /* @__PURE__ */ new Map());
+  return found;
+}
+var AreaIndex = class {
+  cells = /* @__PURE__ */ new Map();
+  chunked = /* @__PURE__ */ new Map();
+  tall = /* @__PURE__ */ new Map();
+  wide = /* @__PURE__ */ new Map();
+  add(area, node) {
+    const { start, end } = area.range;
+    if (start.row === end.row && end.col - start.col + 1 <= BUCKET_WIDTH) {
+      const cells3 = inner(this.cells, area.sheet);
+      for (let col = start.col; col <= end.col; col++) push(cells3, cellKey(start.row, col), node);
+      return;
+    }
+    const entry3 = { range: area.range, node };
+    if (end.col - start.col + 1 > BUCKET_WIDTH) {
+      const list = this.wide.get(area.sheet);
+      if (list) list.push(entry3);
+      else this.wide.set(area.sheet, [entry3]);
+      return;
+    }
+    const first3 = start.row >> CHUNK_SHIFT;
+    const last = end.row >> CHUNK_SHIFT;
+    if (last - first3 + 1 > CHUNKS) {
+      const cols2 = inner(this.tall, area.sheet);
+      for (let c2 = start.col; c2 <= end.col; c2++) push(cols2, c2, entry3);
+      return;
+    }
+    const cols = inner(this.chunked, area.sheet);
+    for (let c2 = start.col; c2 <= end.col; c2++) {
+      let chunks = cols.get(c2);
+      if (!chunks) cols.set(c2, chunks = /* @__PURE__ */ new Map());
+      for (let k = first3; k <= last; k++) push(chunks, k, entry3);
+    }
+  }
+  /** Items whose areas intersect `range` on `sheet` (each once). */
+  dependents(sheet, range, out) {
+    const found = out instanceof Set ? out : /* @__PURE__ */ new Set();
+    this.collect(sheet, range, found);
+    if (Array.isArray(out)) for (const node of found) out.push(node);
+  }
+  collect(sheet, range, out) {
+    const { start, end } = range;
+    const check3 = (list) => {
+      if (list) {
+        for (const entry3 of list) if (rangesIntersect(entry3.range, range)) out.add(entry3.node);
+      }
+    };
+    const cells3 = this.cells.get(sheet);
+    if (cells3) {
+      const size = (end.row - start.row + 1) * (end.col - start.col + 1);
+      if (size <= 4096) {
+        for (let r = start.row; r <= end.row; r++) {
+          for (let c2 = start.col; c2 <= end.col; c2++) {
+            const list = cells3.get(cellKey(r, c2));
+            if (list) for (const node of list) out.add(node);
+          }
+        }
+      } else {
+        for (const [key2, list] of cells3) {
+          const { row: row2, col } = keyToAddress(key2);
+          if (row2 >= start.row && row2 <= end.row && col >= start.col && col <= end.col)
+            for (const node of list) out.add(node);
+        }
+      }
+    }
+    const columns = (map, visit2) => {
+      if (!map) return;
+      if (end.col - start.col + 1 <= map.size) {
+        for (let c2 = start.col; c2 <= end.col; c2++) if (map.has(c2)) visit2(c2);
+      } else for (const c2 of map.keys()) if (c2 >= start.col && c2 <= end.col) visit2(c2);
+    };
+    const chunked = this.chunked.get(sheet);
+    const first3 = start.row >> CHUNK_SHIFT;
+    const last = end.row >> CHUNK_SHIFT;
+    columns(chunked, (c2) => {
+      const chunks = chunked?.get(c2);
+      if (last - first3 + 1 <= chunks.size) {
+        for (let k = first3; k <= last; k++) check3(chunks.get(k));
+      } else for (const [k, list] of chunks) if (k >= first3 && k <= last) check3(list);
+    });
+    const tall = this.tall.get(sheet);
+    columns(tall, (c2) => check3(tall?.get(c2)));
+    check3(this.wide.get(sheet));
+  }
+};
+
+// xlsx/formula/graph-index.ts
+var ColumnIndex = class {
+  sheets = /* @__PURE__ */ new Map();
+  constructor(nodes) {
+    for (const node of nodes) {
+      let cols = this.sheets.get(node.sheet);
+      if (!cols) this.sheets.set(node.sheet, cols = /* @__PURE__ */ new Map());
+      let list = cols.get(node.col);
+      if (!list) cols.set(node.col, list = []);
+      list.push(node);
+    }
+    for (const cols of this.sheets.values())
+      for (const list of cols.values()) list.sort((a2, b) => a2.row - b.row);
+  }
+  nodesIn(area, out) {
+    const cols = this.sheets.get(area.sheet);
+    if (!cols) return;
+    const { start, end } = area.range;
+    const width = end.col - start.col + 1;
+    const scan3 = (list) => {
+      let lo = 0;
+      let hi = list.length;
+      while (lo < hi) {
+        const mid = lo + hi >> 1;
+        if (list[mid].row < start.row) lo = mid + 1;
+        else hi = mid;
+      }
+      for (let i2 = lo; i2 < list.length; i2++) {
+        const node = list[i2];
+        if (node.row > end.row) break;
+        out.push(node);
+      }
+    };
+    if (width <= cols.size) {
+      for (let c2 = start.col; c2 <= end.col; c2++) {
+        const list = cols.get(c2);
+        if (list) scan3(list);
+      }
+    } else {
+      for (const [c2, list] of cols) if (c2 >= start.col && c2 <= end.col) scan3(list);
+    }
+  }
+};
+var ReverseIndex = class extends AreaIndex {
+  constructor(nodes = []) {
+    super();
+    for (const node of nodes) this.addNode(node);
+  }
+  /** Indexes one more formula's precedents. */
+  addNode(node) {
+    for (const dep of node.deps) this.add(dep, node);
+    for (const dep of node.dynamicDeps) this.add(dep, node);
+  }
+};
+
+// xlsx/formula/engine-prepare.ts
+var CHECK_EVERY = 32;
+var GraphPreparation = class {
+  constructor(workbook, create) {
+    this.workbook = workbook;
+    this.create = create;
+  }
+  workbook;
+  create;
+  reverse = new ReverseIndex();
+  formulas = { dynamic: [], unvalued: [] };
+  sheet = 0;
+  rows;
+  row = 0;
+  cells;
+  finished = false;
+  /**
+   * Adds formulas to the graph until `timeRemaining` (milliseconds, as an idle deadline reports
+   * them) reaches zero, or until every formula is in. Returns true when the graph is complete.
+   */
+  run(timeRemaining) {
+    let visited = 0;
+    while (!this.finished) {
+      const cells3 = this.cells ?? this.nextRow();
+      if (!cells3) continue;
+      const next = cells3.next();
+      if (next.done) {
+        this.cells = void 0;
+        continue;
+      }
+      const [col, cell] = next.value;
+      if (cell.formula) this.add(this.create(this.sheet, this.row, col, cell), cell);
+      if (timeRemaining && ++visited % CHECK_EVERY === 0 && timeRemaining() <= 0) break;
+    }
+    return this.finished;
+  }
+  add(node, cell) {
+    this.reverse.addNode(node);
+    if (!node.legacy && !node.arrayRange) this.formulas.dynamic.push(node);
+    if (cell.value === null && !node.keepCached) this.formulas.unvalued.push(node);
+  }
+  /** Moves to the next stored row (and sheet), or marks the walk finished. */
+  nextRow() {
+    for (; ; ) {
+      const sheet = this.workbook.sheets[this.sheet];
+      if (!sheet) {
+        this.finished = true;
+        return void 0;
+      }
+      this.rows ??= sheet.rows.entries();
+      const next = this.rows.next();
+      if (!next.done) {
+        this.row = next.value[0];
+        this.cells = next.value[1].entries();
+        return this.cells;
+      }
+      this.rows = void 0;
+      this.sheet++;
+    }
+  }
+};
+
 // xlsx/formula/text-number.ts
 var MONTHS2 = [
   "jan",
@@ -20493,8 +20778,10 @@ var FINANCIAL_FUNCTIONS = [
 
 // xlsx/formula/references.ts
 function sheetIndex(host, name) {
+  const sheets = host.workbook.sheets;
+  for (let i2 = 0; i2 < sheets.length; i2++) if (sheets[i2]?.name === name) return i2;
   const lower2 = name.toLowerCase();
-  return host.workbook.sheets.findIndex((sheet) => sheet.name.toLowerCase() === lower2);
+  return sheets.findIndex((sheet) => sheet.name.toLowerCase() === lower2);
 }
 function prefixSheets(host, prefix, current) {
   if (!prefix) return [current];
@@ -22108,9 +22395,9 @@ function readBlock(ctx, area, rows, cols) {
   if (host.readBlock) return host.readBlock(area.sheet, range);
   return Matrix.build(rows, cols, (r, c2) => ctx.readCell(area.sheet, row2 + r, col + c2));
 }
-function shapedMatrices(ctx, values2, sameShape) {
+function shapedMatrices(ctx, values2, sameShape2) {
   let { rows, cols } = shapeOf(values2[0] ?? null);
-  if (sameShape) {
+  if (sameShape2) {
     for (const value of values2) {
       const shape2 = shapeOf(value);
       if (shape2.rows !== rows || shape2.cols !== cols) fail(ERR.VALUE);
@@ -22136,12 +22423,12 @@ function shapedMatrices(ctx, values2, sameShape) {
   });
   return { matrices, total: total2, block: rows * cols };
 }
-function matchingCells(ctx, pairs, target, sameShape) {
+function matchingCells(ctx, pairs, target, sameShape2) {
   const ranges = pairs.map((p) => p.range);
   const { matrices, total: total2, block } = shapedMatrices(
     ctx,
     target === void 0 ? ranges : [...ranges, target],
-    sameShape
+    sameShape2
   );
   const tests = pairs.map((p) => makeCriteria(scalar(p.criteria)));
   const values2 = matrices[matrices.length - 1];
@@ -22180,7 +22467,7 @@ function indexedCandidates(pairs, matrices) {
   }
   return void 0;
 }
-var matchingValues = (ctx, pairs, target, sameShape) => matchingCells(ctx, pairs, target, sameShape).values;
+var matchingValues = (ctx, pairs, target, sameShape2) => matchingCells(ctx, pairs, target, sameShape2).values;
 function criteriaPairs(args, from) {
   if ((args.length - from) % 2 !== 0) fail(ERR.VALUE);
   const pairs = [];
@@ -26074,7 +26361,7 @@ var REFERENCE_ARGUMENT = /* @__PURE__ */ new Set([
   "AREAS",
   "ISREF"
 ]);
-var push = (c2, area) => {
+var push2 = (c2, area) => {
   (c2.dynamic > 0 ? c2.dynamicDeps : c2.deps).push(area);
 };
 function spans(areas) {
@@ -26100,7 +26387,7 @@ function visit(node, c2) {
       if (!sheets) return;
       const range = specRange(node.ref);
       const target = node.spill ? { start: range.start, end: { ...range.start } } : range;
-      for (const sheet of sheets) push(c2, { sheet, range: target });
+      for (const sheet of sheets) push2(c2, { sheet, range: target });
       return;
     }
     case "name": {
@@ -26174,7 +26461,7 @@ function visitBinary(node, c2) {
       const list = c2.dynamic > 0 ? c2.dynamicDeps : c2.deps;
       const l = list[list.length - 2];
       const r = list[list.length - 1];
-      if (l && r && l.sheet === r.sheet) push(c2, spans([l, r])[0]);
+      if (l && r && l.sheet === r.sheet) push2(c2, spans([l, r])[0]);
       continue;
     }
     const mentioned = [...c2.deps.slice(staticStart), ...c2.dynamicDeps.slice(dynamicStart)];
@@ -26190,7 +26477,7 @@ function addStructured(ref, c2) {
     sheet: c2.sheet,
     row: c2.row,
     col: c2.col});
-  if (value instanceof RefValue) for (const area of value.areas) push(c2, area);
+  if (value instanceof RefValue) for (const area of value.areas) push2(c2, area);
 }
 function analyze(ast, host, sheet, row2, col) {
   const c2 = {
@@ -26214,155 +26501,191 @@ function analyze(ast, host, sheet, row2, col) {
   };
 }
 
-// xlsx/formula/area-index.ts
-var BUCKET_WIDTH = 64;
-var CHUNK_SHIFT = 6;
-var CHUNKS = 64;
-function push2(map, key2, value) {
-  const list = map.get(key2);
-  if (list) list.push(value);
-  else map.set(key2, [value]);
+// xlsx/formula/formula-shape.ts
+var isDigit4 = (code) => code >= 48 && code <= 57;
+function formulaShape(formula) {
+  const starts = [];
+  const ends = [];
+  let hash = 2166136261;
+  for (let i2 = 0; i2 < formula.length; i2++) {
+    let code = formula.charCodeAt(i2);
+    if (isDigit4(code)) {
+      let j = i2 + 1;
+      while (j < formula.length && isDigit4(formula.charCodeAt(j))) j++;
+      starts.push(i2);
+      ends.push(j);
+      i2 = j - 1;
+      code = 0;
+    }
+    hash = Math.imul(hash ^ code, 16777619);
+  }
+  return { hash: hash >>> 0, starts, ends };
 }
-function inner(map, sheet) {
-  let found = map.get(sheet);
-  if (!found) map.set(sheet, found = /* @__PURE__ */ new Map());
-  return found;
+function sameText(a2, from, b, at2, length) {
+  for (let k = 0; k < length; k++)
+    if (a2.charCodeAt(from + k) !== b.charCodeAt(at2 + k)) return false;
+  return true;
 }
-var AreaIndex = class {
-  cells = /* @__PURE__ */ new Map();
-  chunked = /* @__PURE__ */ new Map();
-  tall = /* @__PURE__ */ new Map();
-  wide = /* @__PURE__ */ new Map();
-  add(area, node) {
-    const { start, end } = area.range;
-    if (start.row === end.row && end.col - start.col + 1 <= BUCKET_WIDTH) {
-      const cells3 = inner(this.cells, area.sheet);
-      for (let col = start.col; col <= end.col; col++) push2(cells3, cellKey(start.row, col), node);
-      return;
+function sameShape(a2, as, b, bs) {
+  const runs = as.starts.length;
+  if (runs !== bs.starts.length) return false;
+  let fromA = 0;
+  let fromB = 0;
+  for (let i2 = 0; i2 <= runs; i2++) {
+    const toA = i2 < runs ? as.starts[i2] : a2.length;
+    const toB = i2 < runs ? bs.starts[i2] : b.length;
+    if (toA - fromA !== toB - fromB || !sameText(a2, fromA, b, fromB, toA - fromA)) return false;
+    fromA = as.ends[i2] ?? 0;
+    fromB = bs.ends[i2] ?? 0;
+  }
+  return true;
+}
+function makeTemplate(formula, shape2) {
+  let tokens3;
+  let ast;
+  try {
+    tokens3 = tokenize(formula);
+    ast = parseTokens(tokens3);
+  } catch (e) {
+    if (e instanceof RangeError) return new FormulaError(e.message, -1, "#VALUE!");
+    if (e instanceof FormulaError) return e;
+    throw e;
+  }
+  const { starts } = shape2;
+  const slotted = starts.map(() => false);
+  const refs = /* @__PURE__ */ new Map();
+  let run2 = 0;
+  for (const token of tokens3) {
+    const end = token.start + token.text.length;
+    const first3 = run2;
+    while (run2 < starts.length && starts[run2] < end) run2++;
+    const ref = token.kind === "ref" ? token.ref : void 0;
+    if (!ref || ref.kind === "cols") continue;
+    const count2 = ref.kind === "cell" ? 1 : 2;
+    if (run2 - first3 < count2) continue;
+    const at2 = run2 - count2;
+    const indexes2 = count2 === 1 ? [at2] : [at2, at2 + 1];
+    if (indexes2.some((i2) => formula.charCodeAt(starts[i2]) === 48)) continue;
+    for (const i2 of indexes2) slotted[i2] = true;
+    refs.set(ref, count2 === 1 ? { start: at2 } : { start: at2, end: at2 + 1 });
+  }
+  return { formula, shape: shape2, ast, slotted, refs };
+}
+function rowsFor(t, formula, shape2) {
+  if (!sameShape(t.formula, t.shape, formula, shape2)) return void 0;
+  const rows = [];
+  for (let i2 = 0; i2 < shape2.starts.length; i2++) {
+    const start = shape2.starts[i2];
+    const length = shape2.ends[i2] - start;
+    if (!t.slotted[i2]) {
+      const own = t.shape.starts[i2];
+      if (t.shape.ends[i2] - own !== length) return void 0;
+      if (!sameText(t.formula, own, formula, start, length)) return void 0;
+      rows.push(-1);
+      continue;
     }
-    const entry3 = { range: area.range, node };
-    if (end.col - start.col + 1 > BUCKET_WIDTH) {
-      const list = this.wide.get(area.sheet);
-      if (list) list.push(entry3);
-      else this.wide.set(area.sheet, [entry3]);
-      return;
+    if (length > 7 || formula.charCodeAt(start) === 48) return void 0;
+    let row2 = 0;
+    for (let k = start; k < start + length; k++) row2 = row2 * 10 + formula.charCodeAt(k) - 48;
+    if (row2 < 1 || row2 > MAX_ROW + 1) return void 0;
+    rows.push(row2 - 1);
+  }
+  return rows;
+}
+function shiftSpec(spec2, slots, rows) {
+  const startRow = rows[slots.start];
+  const endRow = slots.end === void 0 ? startRow : rows[slots.end];
+  if (startRow === spec2.start.row && endRow === spec2.end.row) return spec2;
+  const { start: from, end: to } = spec2;
+  const start = { row: startRow, col: from.col, rowAbs: from.rowAbs, colAbs: from.colAbs };
+  if (slots.end === void 0) return { kind: spec2.kind, start, end: start };
+  const end = { row: endRow, col: to.col, rowAbs: to.rowAbs, colAbs: to.colAbs };
+  return { kind: spec2.kind, start, end };
+}
+function copyTree(node, t, rows) {
+  switch (node.type) {
+    case "ref": {
+      const slots = node.ref ? t.refs.get(node.ref) : void 0;
+      if (!slots || !node.ref) return node;
+      const ref = shiftSpec(node.ref, slots, rows);
+      if (ref === node.ref) return node;
+      const copy2 = { type: "ref" };
+      if (node.prefix) copy2.prefix = node.prefix;
+      copy2.ref = ref;
+      if (node.spill) copy2.spill = true;
+      return copy2;
     }
-    const first3 = start.row >> CHUNK_SHIFT;
-    const last = end.row >> CHUNK_SHIFT;
-    if (last - first3 + 1 > CHUNKS) {
-      const cols2 = inner(this.tall, area.sheet);
-      for (let c2 = start.col; c2 <= end.col; c2++) push2(cols2, c2, entry3);
-      return;
+    case "unary":
+    case "percent": {
+      const operand4 = copyTree(node.operand, t, rows);
+      if (operand4 === node.operand) return node;
+      return node.type === "unary" ? { type: "unary", op: node.op, operand: operand4 } : { type: "percent", operand: operand4 };
     }
-    const cols = inner(this.chunked, area.sheet);
-    for (let c2 = start.col; c2 <= end.col; c2++) {
-      let chunks = cols.get(c2);
-      if (!chunks) cols.set(c2, chunks = /* @__PURE__ */ new Map());
-      for (let k = first3; k <= last; k++) push2(chunks, k, entry3);
+    case "binary": {
+      const left2 = copyTree(node.left, t, rows);
+      const right2 = copyTree(node.right, t, rows);
+      if (left2 === node.left && right2 === node.right) return node;
+      return { type: "binary", op: node.op, left: left2, right: right2 };
     }
-  }
-  /** Items whose areas intersect `range` on `sheet` (each once). */
-  dependents(sheet, range, out) {
-    const found = out instanceof Set ? out : /* @__PURE__ */ new Set();
-    this.collect(sheet, range, found);
-    if (Array.isArray(out)) for (const node of found) out.push(node);
-  }
-  collect(sheet, range, out) {
-    const { start, end } = range;
-    const check3 = (list) => {
-      if (list) {
-        for (const entry3 of list) if (rangesIntersect(entry3.range, range)) out.add(entry3.node);
-      }
-    };
-    const cells3 = this.cells.get(sheet);
-    if (cells3) {
-      const size = (end.row - start.row + 1) * (end.col - start.col + 1);
-      if (size <= 4096) {
-        for (let r = start.row; r <= end.row; r++) {
-          for (let c2 = start.col; c2 <= end.col; c2++) {
-            const list = cells3.get(cellKey(r, c2));
-            if (list) for (const node of list) out.add(node);
-          }
-        }
-      } else {
-        for (const [key2, list] of cells3) {
-          const { row: row2, col } = keyToAddress(key2);
-          if (row2 >= start.row && row2 <= end.row && col >= start.col && col <= end.col)
-            for (const node of list) out.add(node);
-        }
-      }
+    case "call": {
+      const args = copyAll(node.args, t, rows);
+      if (args === node.args) return node;
+      return { type: "call", name: node.name, rawName: node.rawName, args };
     }
-    const columns = (map, visit2) => {
-      if (!map) return;
-      if (end.col - start.col + 1 <= map.size) {
-        for (let c2 = start.col; c2 <= end.col; c2++) if (map.has(c2)) visit2(c2);
-      } else for (const c2 of map.keys()) if (c2 >= start.col && c2 <= end.col) visit2(c2);
-    };
-    const chunked = this.chunked.get(sheet);
-    const first3 = start.row >> CHUNK_SHIFT;
-    const last = end.row >> CHUNK_SHIFT;
-    columns(chunked, (c2) => {
-      const chunks = chunked?.get(c2);
-      if (last - first3 + 1 <= chunks.size) {
-        for (let k = first3; k <= last; k++) check3(chunks.get(k));
-      } else for (const [k, list] of chunks) if (k >= first3 && k <= last) check3(list);
-    });
-    const tall = this.tall.get(sheet);
-    columns(tall, (c2) => check3(tall?.get(c2)));
-    check3(this.wide.get(sheet));
-  }
-};
-
-// xlsx/formula/graph-index.ts
-var ColumnIndex = class {
-  sheets = /* @__PURE__ */ new Map();
-  constructor(nodes) {
-    for (const node of nodes) {
-      let cols = this.sheets.get(node.sheet);
-      if (!cols) this.sheets.set(node.sheet, cols = /* @__PURE__ */ new Map());
-      let list = cols.get(node.col);
-      if (!list) cols.set(node.col, list = []);
-      list.push(node);
+    case "invoke": {
+      const callee = copyTree(node.callee, t, rows);
+      const args = copyAll(node.args, t, rows);
+      if (callee === node.callee && args === node.args) return node;
+      return { type: "invoke", callee, args };
     }
-    for (const cols of this.sheets.values())
-      for (const list of cols.values()) list.sort((a2, b) => a2.row - b.row);
+    default:
+      return node;
   }
-  nodesIn(area, out) {
-    const cols = this.sheets.get(area.sheet);
-    if (!cols) return;
-    const { start, end } = area.range;
-    const width = end.col - start.col + 1;
-    const scan3 = (list) => {
-      let lo = 0;
-      let hi = list.length;
-      while (lo < hi) {
-        const mid = lo + hi >> 1;
-        if (list[mid].row < start.row) lo = mid + 1;
-        else hi = mid;
-      }
-      for (let i2 = lo; i2 < list.length; i2++) {
-        const node = list[i2];
-        if (node.row > end.row) break;
-        out.push(node);
-      }
-    };
-    if (width <= cols.size) {
-      for (let c2 = start.col; c2 <= end.col; c2++) {
-        const list = cols.get(c2);
-        if (list) scan3(list);
-      }
-    } else {
-      for (const [c2, list] of cols) if (c2 >= start.col && c2 <= end.col) scan3(list);
-    }
+}
+function copyAll(nodes, t, rows) {
+  let out;
+  for (let i2 = 0; i2 < nodes.length; i2++) {
+    const node = nodes[i2];
+    const copy2 = copyTree(node, t, rows);
+    if (copy2 !== node && !out) out = nodes.slice(0, i2);
+    out?.push(copy2);
+  }
+  return out ?? nodes;
+}
+function fromTemplate(t, formula, shape2) {
+  const rows = rowsFor(t, formula, shape2);
+  return rows ? copyTree(t.ast, t, rows) : void 0;
+}
+
+// xlsx/formula/parse-cache.ts
+var MAX_TEMPLATE_LENGTH = 2048;
+var MAX_ENTRIES = 1e5;
+var MAX_TEMPLATES2 = 1e4;
+var NO_RUNS = { hash: 0, starts: [], ends: [] };
+var treeOf = (made) => "ast" in made ? made.ast : made;
+var ParseCache = class {
+  byText = /* @__PURE__ */ new Map();
+  templates = /* @__PURE__ */ new Map();
+  parse(formula) {
+    let ast = this.byText.get(formula);
+    if (ast) return ast;
+    ast = this.parseNew(formula);
+    if (this.byText.size > MAX_ENTRIES) this.byText.clear();
+    this.byText.set(formula, ast);
+    return ast;
   }
-};
-var ReverseIndex = class extends AreaIndex {
-  constructor(nodes) {
-    super();
-    for (const node of nodes) {
-      for (const dep of node.deps) this.add(dep, node);
-      for (const dep of node.dynamicDeps) this.add(dep, node);
+  parseNew(formula) {
+    if (formula.length > MAX_TEMPLATE_LENGTH) return treeOf(makeTemplate(formula, NO_RUNS));
+    const shape2 = formulaShape(formula);
+    const template = this.templates.get(shape2.hash);
+    const reused = template && fromTemplate(template, formula, shape2);
+    if (reused) return reused;
+    const made = makeTemplate(formula, shape2);
+    if (!template && "ast" in made) {
+      if (this.templates.size > MAX_TEMPLATES2) this.templates.clear();
+      this.templates.set(shape2.hash, made);
     }
+    return treeOf(made);
   }
 };
 
@@ -26502,7 +26825,7 @@ var EngineHost = class {
   options;
   nodes = /* @__PURE__ */ new Map();
   footprints = /* @__PURE__ */ new Set();
-  astCache = /* @__PURE__ */ new Map();
+  parsed = new ParseCache();
   boundsCache = /* @__PURE__ */ new Map();
   inProgress = /* @__PURE__ */ new Set();
   cycles = /* @__PURE__ */ new Set();
@@ -26526,6 +26849,8 @@ var EngineHost = class {
   evaluations = 0;
   built = false;
   needsFull = false;
+  /** No recalculation has run since the workbook was opened: stored values may stand. */
+  fresh = true;
   // ---- EvalHost ----
   readCell(sheet, row2, col) {
     const cell = this.workbook.sheets[sheet]?.rows.get(row2)?.get(col);
@@ -26614,19 +26939,7 @@ var EngineHost = class {
     return this.workbook.sheets[sheet]?.rows.get(row2)?.get(col)?.formula;
   }
   parse(formula) {
-    let ast = this.astCache.get(formula);
-    if (!ast) {
-      try {
-        ast = parseFormula(formula);
-      } catch (e) {
-        if (e instanceof RangeError) ast = new FormulaError(e.message, -1, "#VALUE!");
-        else if (!(e instanceof FormulaError)) throw e;
-        else ast = e;
-      }
-      if (this.astCache.size > 1e5) this.astCache.clear();
-      this.astCache.set(formula, ast);
-    }
-    return ast;
+    return this.parsed.parse(formula);
   }
   now() {
     return this.options.now ? this.options.now() : /* @__PURE__ */ new Date();
@@ -26635,20 +26948,6 @@ var EngineHost = class {
     return this.options.random ? this.options.random() : Math.random();
   }
   // ---- graph ----
-  build() {
-    this.nodes.clear();
-    this.footprints.clear();
-    this.footprintIndex = void 0;
-    this.workbook.sheets.forEach((sheet, s) => {
-      for (const [row2, cells3] of sheet.rows) {
-        for (const [col, cell] of cells3) {
-          if (cell.formula) this.createNode(s, row2, col, cell, true);
-        }
-      }
-    });
-    this.built = true;
-    this.graphChanged();
-  }
   createNode(sheet, row2, col, cell, initial) {
     const formula = cell.formula ?? "";
     const parsed = this.parse(formula);
@@ -26677,6 +26976,14 @@ var EngineHost = class {
     map.set(cellKey(row2, col), node);
     return node;
   }
+  /** Parses a node's text again after a structural edit rewrote it (see `FormulaNode.stale`). */
+  refreshAst(node) {
+    const parsed = this.parse(node.formula);
+    delete node.stale;
+    delete node.parseError;
+    node.ast = parsed instanceof FormulaError ? void 0 : parsed;
+    if (parsed instanceof FormulaError && parsed.code) node.parseError = err(parsed.code);
+  }
   removeNode(node, changed) {
     const sheet = this.workbook.sheets[node.sheet];
     if (node.spill && sheet) {
@@ -27107,6 +27414,7 @@ var EngineCore = class extends EngineHost {
     return { host: this, sheet, row: row2, col, scope: void 0, depth: 0, root, legacy };
   }
   evaluateFormula(node) {
+    if (node.stale) this.refreshAst(node);
     if (!node.ast) return node.parseError ?? ERR.NAME;
     const ast = node.ast;
     const frame = this.frameFor(node.sheet, node.row, node.col, ast, node.legacy);
@@ -27124,20 +27432,363 @@ var EngineCore = class extends EngineHost {
   }
 };
 
+// xlsx/formula/shift-graph.ts
+var POSITIONAL = /* @__PURE__ */ new Set(["ROW", "COLUMN"]);
+var DESCRIPTIVE = /* @__PURE__ */ new Set(["FORMULATEXT", "CELL", "SHEET"]);
+var traitsCache = /* @__PURE__ */ new WeakMap();
+function astTraits(ast) {
+  const cached3 = traitsCache.get(ast);
+  if (cached3) return cached3;
+  const sheets = /* @__PURE__ */ new Set();
+  const traits = { complex: false, opaque: false, positional: false, descriptive: false, sheets };
+  const stack2 = [ast];
+  while (stack2.length) {
+    const node = stack2.pop();
+    switch (node.type) {
+      case "ref":
+        if (node.prefix) {
+          sheets.add(node.prefix.sheet.toLowerCase());
+          if (node.prefix.sheet2 !== void 0) {
+            sheets.add(node.prefix.sheet2.toLowerCase());
+            traits.complex = true;
+          }
+        }
+        break;
+      case "name":
+        if (node.prefix) sheets.add(node.prefix.sheet.toLowerCase());
+        traits.complex = true;
+        break;
+      case "structured":
+        traits.complex = true;
+        break;
+      case "unary":
+      case "percent":
+        stack2.push(node.operand);
+        break;
+      case "binary":
+        stack2.push(node.left, node.right);
+        break;
+      case "call":
+        if (POSITIONAL.has(node.name)) traits.positional = true;
+        if (DESCRIPTIVE.has(node.name)) traits.descriptive = true;
+        if (!getFunction(node.name)) traits.complex = traits.opaque = true;
+        stack2.push(...node.args);
+        break;
+      case "invoke":
+        stack2.push(node.callee, ...node.args);
+        break;
+    }
+  }
+  traitsCache.set(ast, traits);
+  return traits;
+}
+function intervalDelta(a2, b, shift2) {
+  const { at: at2, count: count2 } = shift2;
+  if (count2 > 0) {
+    if (b < at2) return 0;
+    if (a2 < at2) return void 0;
+    return b + count2 > (shift2.axis === "row" ? MAX_ROW : MAX_COL) ? void 0 : count2;
+  }
+  const last = at2 - count2 - 1;
+  if (b < at2) return 0;
+  if (a2 > last) return count2;
+  return void 0;
+}
+function areaDelta(area, sheet, shift2) {
+  if (area.sheet !== sheet) return 0;
+  const { start, end } = area.range;
+  return shift2.axis === "row" ? intervalDelta(start.row, end.row, shift2) : intervalDelta(start.col, end.col, shift2);
+}
+function movedRange(range, axis, delta) {
+  if (delta === 0) return range;
+  return axis === "row" ? {
+    start: { row: range.start.row + delta, col: range.start.col },
+    end: { row: range.end.row + delta, col: range.end.col }
+  } : {
+    start: { row: range.start.row, col: range.start.col + delta },
+    end: { row: range.end.row, col: range.end.col + delta }
+  };
+}
+function reachesEdit(areas, sheet, shift2) {
+  for (const area of areas) {
+    if (area.sheet !== sheet) continue;
+    if ((shift2.axis === "row" ? area.range.end.row : area.range.end.col) >= shift2.at) return true;
+  }
+  return false;
+}
+function intersectionMoves(area, delta, pos, nodeDelta, axis) {
+  if (delta === nodeDelta) return false;
+  const { start, end } = area.range;
+  const a2 = axis === "row" ? start.row : start.col;
+  const b = axis === "row" ? end.row : end.col;
+  if (a2 === b) return false;
+  return pos >= a2 && pos <= b || pos + nodeDelta >= a2 + delta && pos + nodeDelta <= b + delta;
+}
+
+// xlsx/formula/engine-structure.ts
+var sameAreas = (a2, b) => a2.length === b.length && a2.every((x, i2) => {
+  const y = b[i2];
+  return x.sheet === y.sheet && sameRange(x.range, y.range);
+});
+var EngineStructure = class extends EngineCore {
+  /** Formulas a structural edit left to recalculate (with their dependents) on the next pass. */
+  structuralSeeds = /* @__PURE__ */ new Set();
+  /** Whether the graph describes the workbook as it was before the edit just reported. */
+  graphReady() {
+    return this.built && !this.needsFull;
+  }
+  /** Parses a node's current text again and recomputes its precedents. */
+  reanalyze(node) {
+    const parsed = this.parse(node.formula);
+    delete node.stale;
+    delete node.parseError;
+    if (parsed instanceof FormulaError) {
+      node.ast = void 0;
+      if (parsed.code) node.parseError = err(parsed.code);
+      node.deps = [];
+      node.dynamicDeps = [];
+      return;
+    }
+    node.ast = parsed;
+    const found = analyze(parsed, this, node.sheet, node.row, node.col);
+    node.deps = found.deps;
+    node.dynamicDeps = found.dynamicDeps;
+    node.volatile = found.volatile;
+    node.unsupported = found.unsupported;
+  }
+  /**
+   * Moves the graph for rows or columns inserted or deleted on `sheet`, after the workbook was
+   * changed (cells moved, formulas rewritten). Spills on the sheet, array formulas the edit cuts
+   * and anything unexpected fall back to a rebuild on the next recalculation.
+   */
+  shiftCells(sheet, shift2) {
+    if (!this.graphReady() || !this.shiftable(sheet, shift2)) {
+      this.invalidate();
+      return;
+    }
+    const ws = this.workbook.sheets[sheet];
+    const own = this.nodes.get(sheet);
+    if (!ws) return;
+    const moved = /* @__PURE__ */ new Map();
+    if (own) {
+      const next = /* @__PURE__ */ new Map();
+      for (const node of own.values()) {
+        const pos = shift2.axis === "row" ? node.row : node.col;
+        const delta = intervalDelta(pos, pos, shift2);
+        if (delta === void 0) {
+          this.dropNode(node);
+          continue;
+        }
+        if (delta !== 0) {
+          moved.set(node, delta);
+          if (shift2.axis === "row") node.row += delta;
+          else node.col += delta;
+        }
+        next.set(cellKey(node.row, node.col), node);
+      }
+      this.nodes.set(sheet, next);
+    }
+    for (const map of this.nodes.values())
+      for (const node of map.values()) {
+        if (!this.shiftNode(node, sheet, shift2, moved.get(node) ?? 0)) {
+          this.invalidate();
+          return;
+        }
+      }
+    this.boundsCache.clear();
+    this.graphChanged();
+  }
+  /** No spill or stale spilled value on the sheet, and no array formula the edit cuts. */
+  shiftable(sheet, shift2) {
+    for (const node of this.footprints) {
+      if (node.sheet !== sheet) continue;
+      if (node.spill || node.blockedSpill) return false;
+      if (node.arrayRange && areaDelta({ sheet, range: node.arrayRange }, sheet, shift2) === void 0)
+        return false;
+    }
+    const ws = this.workbook.sheets[sheet];
+    let spilled = false;
+    ws?.rows.forEach((cells3) => {
+      if (!spilled) cells3.forEach((cell) => spilled ||= isSpilledCell(cell));
+    });
+    return !spilled;
+  }
+  dropNode(node) {
+    this.structuralSeeds.delete(node);
+    this.cycles.delete(node);
+    this.footprints.delete(node);
+  }
+  /** Updates one formula for the edit; false when the graph cannot follow it. */
+  shiftNode(node, sheet, shift2, nodeDelta) {
+    const cell = this.workbook.sheets[node.sheet]?.rows.get(node.row)?.get(node.col);
+    if (cell?.formula === void 0) return false;
+    if (node.arrayRange) {
+      const delta = areaDelta({ sheet: node.sheet, range: node.arrayRange }, sheet, shift2);
+      if (delta === void 0) return false;
+      node.arrayRange = movedRange(node.arrayRange, shift2.axis, delta);
+      if (!cell.arrayRange || !sameRange(node.arrayRange, normalizeRange(cell.arrayRange)))
+        return false;
+    }
+    const changed = cell.formula !== node.formula;
+    const traits = node.ast && astTraits(node.ast);
+    const reached = reachesEdit(node.deps, sheet, shift2) || reachesEdit(node.dynamicDeps, sheet, shift2);
+    if (!changed && !reached && nodeDelta === 0 && !traits?.descriptive && !traits?.opaque)
+      return true;
+    if (traits?.complex) {
+      node.formula = cell.formula;
+      this.reanalyze(node);
+      this.structuralSeeds.add(node);
+      return true;
+    }
+    const pos = shift2.axis === "row" ? node.row - nodeDelta : node.col - nodeDelta;
+    const moves = { seed: !!traits?.descriptive, moved: false, cut: false };
+    const deps = this.moveAreas(node.deps, sheet, shift2, pos, nodeDelta, moves);
+    const dynamicDeps = this.moveAreas(node.dynamicDeps, sheet, shift2, pos, nodeDelta, moves);
+    const { cut, moved: anyMoved } = moves;
+    let seed = moves.seed;
+    if (cut || changed !== anyMoved) {
+      node.formula = cell.formula;
+      this.reanalyze(node);
+      this.structuralSeeds.add(node);
+      return true;
+    }
+    if (traits?.positional && (anyMoved || nodeDelta !== 0)) seed = true;
+    node.deps = deps;
+    node.dynamicDeps = dynamicDeps;
+    if (changed) {
+      node.formula = cell.formula;
+      node.stale = true;
+    }
+    if (seed) this.structuralSeeds.add(node);
+    return true;
+  }
+  /**
+   * Areas moved for the edit (the same list when none moves). Records in `moves` whether one
+   * moved, one was cut (deleted, widened, pushed off the grid) and whether implicit intersection
+   * with one can now pick another cell.
+   */
+  moveAreas(list, sheet, shift2, pos, nodeDelta, moves) {
+    let out;
+    for (let i2 = 0; i2 < list.length; i2++) {
+      const area = list[i2];
+      const delta = areaDelta(area, sheet, shift2);
+      if (delta === void 0) {
+        moves.cut = true;
+        continue;
+      }
+      if (intersectionMoves(area, delta, pos, nodeDelta, shift2.axis)) moves.seed = true;
+      if (delta === 0) continue;
+      moves.moved = true;
+      out ??= list.slice();
+      out[i2] = { sheet: area.sheet, range: movedRange(area.range, shift2.axis, delta) };
+    }
+    return out ?? list;
+  }
+  /**
+   * Follows a sheet rename (`from` to `to`, formulas already rewritten): precedents are kept by
+   * sheet index, so only rewritten formulas need their text parsed again, and only formulas that
+   * name the new sheet without having been rewritten (previously unresolved), describe sheets
+   * (CELL, SHEET, FORMULATEXT) or read defined names whose areas changed are recalculated.
+   */
+  renameSheet(from, to) {
+    if (!this.graphReady()) {
+      this.invalidate();
+      return;
+    }
+    const target = to.toLowerCase();
+    let depsChanged = false;
+    for (const map of this.nodes.values())
+      for (const node of map.values()) {
+        const cell = this.workbook.sheets[node.sheet]?.rows.get(node.row)?.get(node.col);
+        if (cell?.formula === void 0) {
+          this.invalidate();
+          return;
+        }
+        const changed = cell.formula !== node.formula;
+        const traits = node.ast && astTraits(node.ast);
+        node.formula = cell.formula;
+        if (traits?.complex || !changed && traits?.sheets.has(target)) {
+          const deps = node.deps;
+          const dynamicDeps = node.dynamicDeps;
+          this.reanalyze(node);
+          const same5 = sameAreas(deps, node.deps) && sameAreas(dynamicDeps, node.dynamicDeps);
+          if (!same5) depsChanged = true;
+          if (!same5 || !traits?.complex) this.structuralSeeds.add(node);
+        } else if (changed) node.stale = true;
+        if (traits?.descriptive || traits?.opaque) this.structuralSeeds.add(node);
+      }
+    if (depsChanged) this.graphChanged();
+  }
+  /** Takes the formulas queued by structural edits. */
+  takeStructuralSeeds(into) {
+    for (const node of this.structuralSeeds)
+      if (this.nodes.get(node.sheet)?.get(cellKey(node.row, node.col)) === node) into.add(node);
+    this.structuralSeeds.clear();
+  }
+};
+
 // xlsx/formula/engine.ts
-var Engine = class extends EngineCore {
+var Engine = class extends EngineStructure {
+  preparation;
+  /** The prepared formulas the first recalculation checks (see `trustsStoredValues`). */
+  prepared;
+  // ---- the graph ----
+  prepare(timeRemaining) {
+    if (this.built || this.needsFull) return true;
+    this.preparation ??= this.startPreparation();
+    if (!this.preparation.run(timeRemaining)) return false;
+    this.finishPreparation(this.preparation);
+    return true;
+  }
+  discardPreparation() {
+    if (!this.fresh || this.needsFull) return;
+    this.preparation = void 0;
+    this.prepared = void 0;
+    this.structuralSeeds.clear();
+    this.nodes.clear();
+    this.footprints.clear();
+    this.graphChanged();
+    this.built = false;
+  }
+  /** Completes the graph, continuing a preparation that is under way. */
+  build() {
+    const preparation = this.preparation ?? this.startPreparation();
+    preparation.run();
+    this.finishPreparation(preparation);
+  }
+  startPreparation() {
+    this.nodes.clear();
+    this.footprints.clear();
+    this.footprintIndex = void 0;
+    this.prepared = void 0;
+    return new GraphPreparation(
+      this.workbook,
+      (s, row2, col, cell) => this.createNode(s, row2, col, cell, true)
+    );
+  }
+  finishPreparation(preparation) {
+    this.preparation = void 0;
+    this.built = true;
+    this.graphChanged();
+    this.reverseIndex = preparation.reverse;
+    this.prepared = preparation.formulas;
+  }
   // ---- recalculation ----
   recalculateAll() {
+    this.fresh = false;
+    this.prepared = void 0;
     if (this.needsFull) this.releaseAllSpills();
     if (!this.built || this.needsFull) this.build();
     this.needsFull = false;
+    this.structuralSeeds.clear();
     this.cycles = /* @__PURE__ */ new Set();
     this.run(new Set(this.allNodes()), true);
   }
   recalculateFrom(changes) {
     const seeds = /* @__PURE__ */ new Set();
-    if (!this.built && !this.needsFull) {
-      this.build();
+    if (this.fresh && !this.needsFull) {
+      this.fresh = false;
+      if (!this.built) this.build();
       if (!this.trustsStoredValues(changes, seeds)) {
         this.recalculateAll();
         return;
@@ -27181,6 +27832,7 @@ var Engine = class extends EngineCore {
       }
     }
     if (structural) this.graphChanged();
+    this.takeStructuralSeeds(seeds);
     const reverse2 = this.reverse();
     for (const area of changed) reverse2.dependents(area.sheet, area.range, seeds);
     for (const node of this.allNodes()) if (node.volatile) seeds.add(node);
@@ -27192,13 +27844,18 @@ var Engine = class extends EngineCore {
    * without a value into `missing`.
    */
   trustsStoredValues(changes, missing) {
+    const prepared = this.prepared;
+    this.prepared = void 0;
+    if (!prepared) return false;
     const changed = new Set(changes.map((c2) => `${c2.sheet}:${cellKey(c2.row, c2.col)}`));
-    for (const node of this.allNodes()) {
-      const legacyOrArray = node.legacy || node.arrayRange;
-      if (!legacyOrArray && !changed.has(`${node.sheet}:${cellKey(node.row, node.col)}`))
+    const current = (node) => this.nodes.get(node.sheet)?.get(cellKey(node.row, node.col)) === node;
+    for (const node of prepared.dynamic) {
+      if (current(node) && !changed.has(`${node.sheet}:${cellKey(node.row, node.col)}`))
         return false;
+    }
+    for (const node of prepared.unvalued) {
       const cell = this.workbook.sheets[node.sheet]?.rows.get(node.row)?.get(node.col);
-      if (cell && cell.value === null && !node.keepCached) missing.add(node);
+      if (current(node) && cell && cell.value === null) missing.add(node);
     }
     return true;
   }
@@ -27212,7 +27869,10 @@ var Engine = class extends EngineCore {
     return !!anchor?.spill && rangeHas(anchor.spill, row2, col);
   }
   invalidate() {
+    this.structuralSeeds.clear();
     this.releaseAllSpills();
+    this.preparation = void 0;
+    this.prepared = void 0;
     this.nodes.clear();
     this.footprints.clear();
     this.graphChanged();
@@ -27236,8 +27896,8 @@ var Engine = class extends EngineCore {
   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);
@@ -27701,7 +28361,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);
@@ -27725,7 +28385,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);
@@ -27919,7 +28579,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 });
@@ -30143,13 +30803,13 @@ function linearTrend(values2) {
   const slope = den ? num3 / den : 0;
   return (k) => Number((meanY + slope * (k - meanX)).toPrecision(15));
 }
-var isDigit4 = (ch) => ch !== void 0 && ch >= "0" && ch <= "9";
+var isDigit5 = (ch) => ch !== void 0 && ch >= "0" && ch <= "9";
 function matchTextNumber(text2) {
   let end = text2.length;
-  while (end > 0 && !isDigit4(text2[end - 1])) end--;
+  while (end > 0 && !isDigit5(text2[end - 1])) end--;
   if (end === 0) return null;
   let start = end;
-  while (start > 0 && isDigit4(text2[start - 1])) start--;
+  while (start > 0 && isDigit5(text2[start - 1])) start--;
   return [text2, text2.slice(0, start), text2.slice(start, end), text2.slice(end)];
 }
 var QUARTER = /^(q|qtr|quarter)(\s?)([1-4])$/i;
@@ -30332,10 +30992,10 @@ function removeValidationArea(rules, area) {
 }
 
 // xlsx/edit/conditional-formulas.ts
-function rewriteConditionalRule(rule2, rewrite3) {
+function rewriteConditionalRule(rule2, rewrite2) {
   const safe2 = (formula) => {
     try {
-      return rewrite3(formula);
+      return rewrite2(formula);
     } catch {
       return formula;
     }
@@ -30854,7 +31514,7 @@ function shiftPreservedXml(sheet, shift2, moveRange, banded) {
     (xml) => xml.includes("sqref")
   );
 }
-function rewritePreservedFormulas(sheet, rewrite3) {
+function rewritePreservedFormulas(sheet, rewrite2) {
   editEntries(
     sheet,
     "extLst",
@@ -30864,7 +31524,7 @@ function rewritePreservedFormulas(sheet, rewrite3) {
         const text2 = f6.textContent ?? "";
         let next = text2;
         try {
-          next = rewrite3(text2, sheet.name);
+          next = rewrite2(text2, sheet.name);
         } catch {
           next = text2;
         }
@@ -30879,46 +31539,46 @@ function rewritePreservedFormulas(sheet, rewrite3) {
 }
 
 // xlsx/edit/shift-formulas.ts
-function safe(rewrite3, formula, formulaSheet) {
+function safe(rewrite2, formula, formulaSheet) {
   try {
-    return rewrite3(formula, formulaSheet);
+    return rewrite2(formula, formulaSheet);
   } catch {
     return formula;
   }
 }
-function rewriteFormulas(workbook, rewrite3) {
-  for (const sheet of workbook.sheets) rewriteSheetFormulas(sheet, rewrite3);
+function rewriteFormulas(workbook, rewrite2) {
+  for (const sheet of workbook.sheets) rewriteSheetFormulas(sheet, rewrite2);
   for (const definedName of workbook.definedNames) {
     const local = definedName.localSheet === void 0 ? void 0 : workbook.sheets[definedName.localSheet];
-    definedName.formula = safe(rewrite3, definedName.formula, local?.name ?? "");
+    definedName.formula = safe(rewrite2, definedName.formula, local?.name ?? "");
   }
 }
-function rewriteSheetFormulas(sheet, rewrite3) {
-  rewritePreservedFormulas(sheet, rewrite3);
+function rewriteSheetFormulas(sheet, rewrite2) {
+  rewritePreservedFormulas(sheet, rewrite2);
   {
     const name = sheet.name;
     for (const table2 of sheet.tables)
       for (const column of table2.columns)
         if (column.calculatedColumnFormula !== void 0)
-          column.calculatedColumnFormula = safe(rewrite3, column.calculatedColumnFormula, name);
+          column.calculatedColumnFormula = safe(rewrite2, column.calculatedColumnFormula, name);
     for (const cells3 of sheet.rows.values())
       for (const cell of cells3.values())
-        if (cell.formula !== void 0) cell.formula = safe(rewrite3, cell.formula, name);
+        if (cell.formula !== void 0) cell.formula = safe(rewrite2, cell.formula, name);
     for (const cf of sheet.conditionalFormats)
-      for (const rule2 of cf.rules) rewriteConditionalRule(rule2, (f6) => rewrite3(f6, name));
+      for (const rule2 of cf.rules) rewriteConditionalRule(rule2, (f6) => rewrite2(f6, name));
     for (const dv of sheet.dataValidations) {
-      if (dv.formula1 !== void 0) dv.formula1 = safe(rewrite3, dv.formula1, name);
-      if (dv.formula2 !== void 0) dv.formula2 = safe(rewrite3, dv.formula2, name);
+      if (dv.formula1 !== void 0) dv.formula1 = safe(rewrite2, dv.formula1, name);
+      if (dv.formula2 !== void 0) dv.formula2 = safe(rewrite2, dv.formula2, name);
     }
     for (const link of sheet.hyperlinks)
       if (link.location && /![A-Za-z$]/.test(link.location))
-        link.location = safe(rewrite3, link.location, name);
+        link.location = safe(rewrite2, link.location, name);
     for (const drawing of sheet.drawings) {
       if (drawing.kind !== "chart") continue;
       for (const series of drawing.series) {
-        if (series.nameRef) series.nameRef = safe(rewrite3, series.nameRef, name);
-        if (series.categoriesRef) series.categoriesRef = safe(rewrite3, series.categoriesRef, name);
-        if (series.valuesRef) series.valuesRef = safe(rewrite3, series.valuesRef, name);
+        if (series.nameRef) series.nameRef = safe(rewrite2, series.nameRef, name);
+        if (series.categoriesRef) series.categoriesRef = safe(rewrite2, series.categoriesRef, name);
+        if (series.valuesRef) series.valuesRef = safe(rewrite2, series.valuesRef, name);
       }
     }
   }
@@ -31105,7 +31765,7 @@ function shiftAxis(ctx, s, axis, at2, count2, insert) {
       applyAxisShift(ctx, sheet, shift2);
       if (insert) inheritFormats(sheet, axis, at2, count2);
     },
-    { sheet: s, structural: true }
+    { sheet: s, structural: true, calc: { kind: "shift", sheet: s, shift: shift2 } }
   );
 }
 var insertRows = (ctx, s, at2, count2) => shiftAxis(ctx, s, "row", at2, count2, true);
@@ -31324,10 +31984,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;
@@ -31412,10 +32072,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) {
@@ -31553,12 +32213,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;
         }
@@ -32919,6 +33579,14 @@ function setCalcMode(ctx, mode) {
 
 // xlsx/edit/session-calc.ts
 var isStructural = (step) => step.structural || step.entries.some((entry3) => entry3.before.kind !== "cells");
+function hintFor(step, mode) {
+  const hint = step.calc;
+  if (!hint) return void 0;
+  if (hint.kind === "rename")
+    return mode === "undo" ? { kind: "rename", from: hint.to, to: hint.from } : hint;
+  return mode === "undo" ? void 0 : hint;
+}
+var settingsOf = (workbook) => `${workbook.iterate ? `${workbook.iterate.count}:${workbook.iterate.delta}` : ""}|${workbook.date1904}`;
 var SessionCalculator = class {
   constructor(workbook, calc, enabled2) {
     this.workbook = workbook;
@@ -32928,43 +33596,113 @@ var SessionCalculator = class {
   workbook;
   calc;
   enabled;
-  /** Structural edits made in manual mode leave the dependency graph stale until a full pass. */
+  /** Structural edits the engine could not follow leave the dependency graph stale (manual mode). */
   staleGraph = false;
+  /** Cells changed in manual mode since the last calculation. */
+  dirty = [];
+  /** The settings at the last calculation; undefined before the first. */
+  calculated;
   /** Recalculates after an applied, undone or redone step (failures become warnings). */
-  afterStep(step) {
-    if (!this.enabled) return;
+  afterStep(step, mode = "apply") {
+    if (!this.enabled) {
+      this.calc.discardPreparation();
+      return;
+    }
+    const structural = isStructural(step);
+    const hint = structural ? hintFor(step, mode) : void 0;
     if (calcModeOf(this.workbook) === "manual") {
-      if (isStructural(step)) this.staleGraph = true;
+      if (hint && !this.staleGraph && !this.dirty.length) {
+        this.guard(() => this.follow(hint));
+        return;
+      }
+      this.calc.discardPreparation();
+      if (structural) this.staleGraph = true;
+      else this.dirty.push(...touchedCells(step));
       return;
     }
-    this.recalc(isStructural(step), () => touchedCells(step));
+    if (hint && !this.staleGraph) {
+      this.guard(() => {
+        this.follow(hint);
+        this.calc.recalculateFrom(touchedCells(step));
+        this.calculated = settingsOf(this.workbook);
+      });
+      return;
+    }
+    this.recalc(structural, () => touchedCells(step));
   }
   /** Recalculates after a change applied outside the history (a collaborator's edit). */
   afterExternal(structural, cells3) {
-    if (!this.enabled) return;
-    if (calcModeOf(this.workbook) === "manual") {
+    if (!this.enabled || calcModeOf(this.workbook) === "manual") {
+      this.calc.discardPreparation();
+      if (!this.enabled) return;
       if (structural) this.staleGraph = true;
+      else this.dirty.push(...cells3);
       return;
     }
     this.recalc(structural, () => cells3);
   }
-  recalc(structural, cells3) {
+  follow(hint) {
+    if (hint.kind === "shift") this.calc.shiftCells(hint.sheet, hint.shift);
+    else this.calc.renameSheet(hint.from, hint.to);
+  }
+  guard(run2) {
     try {
+      run2();
+    } catch (error) {
+      const message = `Recalculation failed: ${error instanceof Error ? error.message : String(error)}`;
+      if (!this.workbook.warnings.includes(message)) this.workbook.warnings.push(message);
+    }
+  }
+  /** Builds the dependency graph ahead of the first edit (see `EditSession.prepareCalculation`). */
+  prepare(timeRemaining) {
+    if (!this.enabled || calcModeOf(this.workbook) === "manual" || this.staleGraph) return true;
+    try {
+      return this.calc.prepare(timeRemaining);
+    } catch {
+      this.calc.discardPreparation();
+      return true;
+    }
+  }
+  /**
+   * Before a structural edit the graph can follow in place: finishes a graph being prepared (or
+   * builds it) while it still matches the workbook, so the edit moves it instead of rebuilding.
+   */
+  beforeStructural() {
+    if (!this.enabled || calcModeOf(this.workbook) === "manual" || this.staleGraph) return;
+    this.prepare();
+  }
+  recalc(structural, cells3) {
+    this.guard(() => {
       if (this.staleGraph || structural) this.full();
       else {
         const changed = cells3();
         if (changed.length) this.calc.recalculateFrom(changed);
+        this.calculated = settingsOf(this.workbook);
       }
-    } catch (error) {
-      const message = `Recalculation failed: ${error instanceof Error ? error.message : String(error)}`;
-      if (!this.workbook.warnings.includes(message)) this.workbook.warnings.push(message);
-    }
+    });
   }
-  /** Rebuilds the dependency graph and recalculates every formula (F9). */
+  /** Rebuilds the dependency graph and recalculates every formula (Ctrl+Alt+F9). */
   full() {
     this.staleGraph = false;
+    this.dirty = [];
     this.calc.invalidate();
     this.calc.recalculateAll();
+    this.calculated = settingsOf(this.workbook);
+  }
+  /**
+   * Calculate Now (F9): the cells changed since the last calculation, the formulas structural
+   * edits queued, their dependents and the volatile functions. Everything when `full`, before
+   * the session's first calculation, after the iteration settings changed or while the graph
+   * is stale.
+   */
+  now(full) {
+    if (full || this.staleGraph || this.calculated !== settingsOf(this.workbook)) {
+      this.full();
+      return;
+    }
+    const changed = this.dirty;
+    this.dirty = [];
+    this.calc.recalculateFrom(changed);
   }
   /**
    * Recalculates one sheet's formulas and their dependents (Shift+F9); after structural edits
@@ -36768,12 +37506,12 @@ function renameSheet(ctx, index2, name) {
   ctx.run(
     "Rename sheet",
     "sheets",
-    [{ kind: "workbook" }],
+    [{ kind: "refs" }],
     () => {
       rewriteFormulas(workbook, (formula) => renameSheetInFormula(formula, old, name));
       sheet.name = name;
     },
-    { sheet: index2, structural: true }
+    { sheet: index2, structural: true, calc: { kind: "rename", from: old, to: name } }
   );
 }
 function moveSheet(ctx, from, to) {
@@ -37149,13 +37887,12 @@ function createEditSession(workbook, options = {}) {
     for (const listener of [...listeners]) listener(change);
   };
   const calculator = new SessionCalculator(workbook, calc, autoRecalc);
-  const recalc = (step) => calculator.afterStep(step);
-  const begin = (label2, kind, info) => ({
-    step: { label: label2, entries: [], structural: info.structural ?? false },
-    kind,
-    sheet: info.sheet,
-    ranges: [...info.ranges ?? []]
-  });
+  const recalc = (step, mode = "apply") => calculator.afterStep(step, mode);
+  const begin = (label2, kind, info) => {
+    const step = { label: label2, entries: [], structural: info.structural ?? false };
+    if (info.calc) step.calc = info.calc;
+    return { step, kind, sheet: info.sheet, ranges: [...info.ranges ?? []] };
+  };
   const finish = (current) => {
     if (!current.step.entries.length) return;
     history.push(current.step);
@@ -37180,10 +37917,12 @@ function createEditSession(workbook, options = {}) {
     const outer = !open;
     const current = open ?? begin(label2, kind, info);
     if (!outer) {
+      delete current.step.calc;
       if (info.structural) current.step.structural = true;
       if (current.sheet === void 0 && info.sheet !== void 0) current.sheet = info.sheet;
       current.ranges.push(...info.ranges ?? []);
     }
+    if (outer && info.calc) calculator.beforeStructural();
     open = current;
     const mark = current.step.entries.length;
     const befores = scopes.map((scope) => captureScope(workbook, scope));
@@ -37231,7 +37970,7 @@ function createEditSession(workbook, options = {}) {
     if (open) throw new Error(`Cannot ${kind} inside a batch`);
     const step = kind === "undo" ? history.undo(workbook) : history.redo(workbook);
     if (!step) return false;
-    recalc(step);
+    recalc(step, kind);
     emit({ kind, label: step.label, structural: step.structural });
     return true;
   };
@@ -37310,10 +38049,11 @@ function createEditSession(workbook, options = {}) {
     setDocumentProperties: (patch) => setDocumentProperties(ctx, patch),
     setAutoRecalc: (enabled2) => setCalcMode(ctx, enabled2 ? "auto" : "manual"),
     autoRecalc: () => autoRecalc && calcModeOf(workbook) === "auto",
-    calculateNow() {
-      calculator.full();
+    calculateNow(options2) {
+      calculator.now(options2?.full ?? false);
       emit({ kind: "cells", label: "Calculate now", structural: false });
     },
+    prepareCalculation: (opts) => calculator.prepare(opts?.timeRemaining),
     calculateSheet(s) {
       calculator.sheet(s);
       emit({ kind: "cells", label: "Calculate sheet", sheet: s, structural: false });
@@ -40438,20 +41178,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,
     { }
   );
@@ -41249,13 +41989,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;
@@ -41263,13 +41997,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],
@@ -41279,9 +42012,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(
@@ -41296,11 +42029,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(
@@ -41317,6 +42053,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;
@@ -41397,6 +42152,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;
@@ -42117,11 +42881,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)),
@@ -42145,7 +42911,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) {
@@ -42155,8 +42922,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) });
@@ -42165,8 +42933,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;
@@ -42187,10 +42956,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,
@@ -42200,13 +42969,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,
@@ -42647,6 +43419,7 @@ var LINE_PROPERTIES = [
   "LineCap",
   "LinePattern",
   "LineColorTrans",
+  "LineGradientEnabled",
   "BeginArrow",
   "EndArrow",
   "BeginArrowSize",
@@ -43218,12 +43991,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"), {
@@ -43390,7 +44177,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
@@ -43545,203 +44337,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
@@ -43827,11 +44428,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]
       )
@@ -43845,7 +44446,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]
     );
   }
@@ -44274,6 +44875,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) {
@@ -44346,14 +45056,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) {
@@ -44605,26 +45307,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);
@@ -44817,6 +45520,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) {
@@ -44846,15 +45550,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",
@@ -44872,6 +45575,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();
@@ -44936,6 +46337,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"));
@@ -45005,7 +46638,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");
@@ -45027,7 +46669,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;
 }
@@ -45036,7 +46678,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;
@@ -45406,6 +47048,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);
@@ -45427,11 +47071,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,
@@ -45624,6 +47272,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);
@@ -45901,11 +47657,11 @@ async function assertVisioMasterIndependence(pkg, roots, commands, check3) {
     }
     const tops = children3(children3(root, "Shapes")[0], "Shape");
     if (tops.length !== 1) problem("Only a uniquely rooted master can prove independence.");
-    const templates = masterShapes(root), context = /* @__PURE__ */ new Map();
+    const templates2 = masterShapes(root), context = /* @__PURE__ */ new Map();
     assertMasterMarkup(
       root,
       new Set(
-        templates.flatMap((shape2) => {
+        templates2.flatMap((shape2) => {
           charge();
           return [...masterCells(shape2, charge).values()];
         })
@@ -45927,7 +47683,7 @@ async function assertVisioMasterIndependence(pkg, roots, commands, check3) {
       if (byTemplate.has(id)) problem("MasterShape mappings are ambiguous.");
       byTemplate.set(id, local);
     }
-    for (const template of templates) {
+    for (const template of templates2) {
       charge();
       if (bindings.length >= 1e4) problem("Master effective binding limit exceeded.");
       check3();
@@ -46255,10 +48011,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);
@@ -46999,6 +48762,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)
@@ -47040,26 +49584,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.");
@@ -47070,10 +49638,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));
@@ -47108,17 +49708,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."
+        }
+      ] : []
+    ]
   };
 }