ooxml-core 1.3.0 → 1.5.0

package/dist/visio/index.cjs

@@ -233,6 +233,19 @@ var attribute = new RegExp(
   "uy"
 );
 var xmlWhitespace = (value) => /^[ \t\r\n]*$/.test(value);
+var reservedNamespaces = /* @__PURE__ */ new Map([
+  ["xml", "http://www.w3.org/XML/1998/namespace"],
+  ["xmlns", "http://www.w3.org/2000/xmlns/"]
+]);
+function lookupNamespace(scope, prefix) {
+  const reserved = reservedNamespaces.get(prefix);
+  if (reserved !== void 0) return reserved;
+  for (; scope; scope = scope.parent) {
+    const uri = scope.bindings.get(prefix);
+    if (uri !== void 0) return uri;
+  }
+  return void 0;
+}
 function inspectXml(xml, limits, check, encoding = "utf-8") {
   if (xml.length > limits.maxXmlChars) fail("LIMIT_XML", "XML character limit exceeded");
   if (/<!DOCTYPE|<!ENTITY/i.test(xml) || /[\u0000-\u0008\u000b\u000c\u000e-\u001f\ufffe\uffff]/.test(xml))
@@ -298,9 +311,7 @@ function inspectXml(xml, limits, check, encoding = "utf-8") {
         fail("INVALID_XML", "Mismatched XML closing tag");
     } else {
       const attrs = /* @__PURE__ */ new Set();
-      const namespaces = Object.create(stack.at(-1)?.namespaces ?? null);
-      namespaces["xml"] = "http://www.w3.org/XML/1998/namespace";
-      namespaces["xmlns"] = "http://www.w3.org/2000/xmlns/";
+      const namespaces = { bindings: /* @__PURE__ */ new Map(), parent: stack.at(-1)?.namespaces };
       while (!xmlWhitespace(body.slice(cursor))) {
         attribute.lastIndex = cursor;
         const match = attribute.exec(body);
@@ -310,14 +321,14 @@ function inspectXml(xml, limits, check, encoding = "utf-8") {
         const value = match[2] ?? match[3] ?? "";
         text(value);
         if (match[1]?.startsWith("xmlns:"))
-          namespaces[match[1].slice(6)] = decodeXmlAttribute(value);
+          namespaces.bindings.set(match[1].slice(6), decodeXmlAttribute(value));
         node();
         cursor = attribute.lastIndex;
       }
       const expanded = /* @__PURE__ */ new Set();
       for (const attr2 of attrs) {
         const colon = attr2.indexOf(":");
-        const uri = colon < 0 ? "" : namespaces[attr2.slice(0, colon)];
+        const uri = colon < 0 ? "" : lookupNamespace(namespaces, attr2.slice(0, colon));
         if (uri === void 0) fail("INVALID_XML", "Unbound XML attribute prefix");
         const key2 = `${uri}\0${attr2.slice(colon + 1)}`;
         if (expanded.has(key2)) fail("INVALID_XML", "Duplicate expanded XML attribute name");
@@ -6601,11 +6612,23 @@ async function parseVsdx(input, options = {}) {
     };
     visit(shapes);
     const connectors = connections(root2, localReport);
+    const pageModes = {};
+    for (const [name, key2] of [
+      ["DrawingSizeType", "drawingSizeType"],
+      ["DrawingResizeType", "drawingResizeType"]
+    ]) {
+      const source = sheet.cells.get(name);
+      if (!source || source.error !== void 0 || source.formula === "Inh" || source.unit !== void 0 && !["NUM", "BOOL"].includes(source.unit))
+        continue;
+      const value = number(sheet.cells, name, Number.NaN, localReport);
+      if (Number.isSafeInteger(value) && value >= 0 && value <= 255) pageModes[key2] = value;
+    }
     for (const connection of connectors)
       if (!seen.has(connection.fromShapeId) || !seen.has(connection.toShapeId))
         localReport("dangling-connection", "A connection references a missing shape.");
     pages.push({
       id,
+      ...pageModes,
       ...drawingToPageScale === 1 ? {} : { drawingToPageScale },
       name: metadata(
         attribute2(page, "Name") ?? attribute2(page, "NameU") ?? `Page ${id}`,
@@ -15234,10 +15257,10 @@ function replaceRecord(input, drawing, record5, replacement) {
     if (!(block.format & 2) || ![8, 12, 13].includes(block.format >>> 4))
       throw new VsdError("unsafe-block-relocation");
     try {
-      const fit = encodeVsdBlockToSize(decoded, block.length);
-      if (!fit)
+      const fit2 = encodeVsdBlockToSize(decoded, block.length);
+      if (!fit2)
         throw new VsdError("unsafe-block-relocation");
-      stored = fit.bytes;
+      stored = fit2.bytes;
     } catch (error) {
       if (error instanceof VsdCompressionFitError)
         throw new VsdError(`compression-${error.reason}`);
@@ -17417,8 +17440,8 @@ function assertUnlayeredShape(shape, document) {
   }
 }
 
-// visio/edit-text.ts
-async function replacePlainText(root2, document, shapeId, text, check, assertDependencies) {
+// visio/edit-text-target.ts
+function localTextTarget(root2, document, shapeId, check) {
   const shapeChildren = (parent) => {
     const containers = children2(parent, "Shapes");
     if (containers.length > 1)
@@ -17426,37 +17449,38 @@ async function replacePlainText(root2, document, shapeId, text, check, assertDep
     return children2(containers[0], "Shape");
   };
   const shapes = /* @__PURE__ */ new Map();
-  const pending = shapeChildren(root2).map((node2) => ({
-    node: node2,
-    inherited: false,
-    deleted: false
-  }));
+  const pending = shapeChildren(root2).map((node) => ({ node, inherited: false, deleted: false }));
   while (pending.length) {
     check();
-    const item = pending.pop();
-    const id = attribute2(item.node, "ID");
+    const item = pending.pop(), id = attribute2(item.node, "ID");
     if (!id || shapes.has(id))
       fail("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(attribute2(item.node, "Del") ?? "");
     shapes.set(id, { node: item.node, inherited, deleted });
-    for (const node2 of shapeChildren(item.node)) pending.push({ node: node2, inherited, deleted });
+    for (const node of shapeChildren(item.node)) pending.push({ node, inherited, deleted });
   }
   const target = shapes.get(shapeId);
   if (!target) fail("EDIT_TARGET_NOT_FOUND", "Local shape does not exist.");
   if (target.inherited || target.deleted)
     fail("UNSUPPORTED_TEXT_EDIT", "Master-linked or deleted shapes cannot be edited.");
   assertShapeLocks(target.node, document, ["LockTextEdit"]);
-  const texts = children2(target.node, "Text");
+  return target.node;
+}
+
+// visio/edit-text.ts
+async function replacePlainText(root2, document, shapeId, text, check, assertDependencies2) {
+  const target = localTextTarget(root2, document, shapeId, check);
+  const texts = children2(target, "Text");
   if (texts.length !== 1)
     fail("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))
     fail("UNSUPPORTED_TEXT_EDIT", "Rich text, fields and unknown text markup cannot be edited.");
-  if (children2(target.node, "Section").some((section) => attribute2(section, "N") === "Field"))
+  if (children2(target, "Section").some((section) => attribute2(section, "N") === "Field"))
     fail("UNSUPPORTED_TEXT_EDIT", "Shapes with text fields cannot be edited.");
   if (decodeVisioPlainText(node.textContent ?? "") === text) return false;
-  await assertDependencies(target.node, node);
+  await assertDependencies2(target, node);
   check();
   while (node.firstChild) node.removeChild(node.firstChild);
   node.appendChild(node.ownerDocument.createTextNode(encodeVisioPlainText(text)));
@@ -17550,6 +17574,394 @@ function replaceScopedPlainText(pkg, pagePaths, roots, document, edit, check) {
   );
 }
 
+// visio/edit-text-range-plan.ts
+function textRangeNodes(node, edit) {
+  const tokens2 = [];
+  let stored = "";
+  for (const part of Array.from(node.childNodes)) {
+    const start = stored.length;
+    if (part.nodeType === 3 || part.nodeType === 4) stored += part.nodeValue ?? "";
+    tokens2.push({ node: part, start, end: stored.length });
+  }
+  if (decodeVisioPlainText(stored) !== edit.expectedText)
+    fail("EDIT_STALE_TEXT", "Original text no longer matches the range command.");
+  const changed = edit.ranges.some(
+    (range) => edit.expectedText.slice(range.start, range.end) !== range.text
+  );
+  if (!changed) return { changed: false, nodes: [] };
+  const starts = [], deltas = [];
+  let delta = 0;
+  for (const range of edit.ranges) {
+    starts.push(range.start + delta);
+    delta += range.text.length - (range.end - range.start);
+    deltas.push(delta);
+  }
+  const length = edit.expectedText.length + delta;
+  if (!length && tokens2.some((token) => token.node.nodeType === 1))
+    fail(
+      "UNSUPPORTED_TEXT_RANGE",
+      "Deleting all rich text has unproven native insertion-style behavior."
+    );
+  if (tokens2.some((token) => token.node.nodeType === 1)) {
+    let start = 0, index = 0;
+    while (start < edit.expectedText.length) {
+      const newline = edit.expectedText.indexOf("\n", start), end = newline < 0 ? edit.expectedText.length : newline;
+      let bodyLength = end - start;
+      while (index < edit.ranges.length && edit.ranges[index].start < end) {
+        const range = edit.ranges[index++];
+        bodyLength += range.text.length - (range.end - range.start);
+      }
+      if (end > start && !bodyLength)
+        fail(
+          "UNSUPPORTED_TEXT_RANGE",
+          "Deleting an entire rich paragraph body has unproven native insertion-style behavior."
+        );
+      start = end + 1;
+    }
+  }
+  const position = (offset) => {
+    let low = 0, high = edit.ranges.length;
+    while (low < high) {
+      const middle = low + high >>> 1;
+      if (edit.ranges[middle].start < offset) low = middle + 1;
+      else high = middle;
+    }
+    const index = low - 1;
+    if (index < 0) return offset;
+    const range = edit.ranges[index];
+    return offset <= range.end ? starts[index] + range.text.length : offset + deltas[index];
+  };
+  const output = [];
+  const append = (token, start, end) => {
+    if (end <= start) return;
+    const part = start === token.start && end === token.end ? token.node : token.node.cloneNode(false);
+    if (part !== token.node)
+      part.nodeValue = (token.node.nodeValue ?? "").slice(start - token.start, end - token.start);
+    output.push({ position: position(start), priority: 2, node: part });
+  };
+  let first2 = 0;
+  for (const token of tokens2) {
+    if (token.node.nodeType === 1) {
+      output.push({ position: position(token.start), priority: 0, node: token.node });
+      continue;
+    }
+    const end = length ? token.end : Math.min(token.end, edit.expectedText.length);
+    let cursor = token.start;
+    while (first2 < edit.ranges.length && edit.ranges[first2].end <= cursor) first2++;
+    for (let index = first2; index < edit.ranges.length && edit.ranges[index].start < end; index++) {
+      const range = edit.ranges[index];
+      append(token, cursor, Math.min(end, range.start));
+      cursor = Math.max(cursor, Math.min(end, range.end));
+    }
+    append(token, cursor, end);
+  }
+  for (let index = 0; index < edit.ranges.length; index++) {
+    const text = edit.ranges[index].text;
+    if (text)
+      output.push({
+        position: starts[index],
+        priority: 1,
+        node: node.ownerDocument.createTextNode(text)
+      });
+  }
+  output.sort((a, b) => a.position - b.position || a.priority - b.priority);
+  let characterPosition = -1, characterRow = null;
+  for (const item of output) {
+    if (item.node.nodeType !== 1 || item.node.localName !== "cp") continue;
+    const row = item.node.getAttribute("IX");
+    if (item.position === characterPosition && row !== characterRow)
+      fail(
+        "UNSUPPORTED_TEXT_RANGE",
+        "Consuming complete character runs creates ambiguous native marker boundaries."
+      );
+    characterPosition = item.position;
+    characterRow = row;
+  }
+  return { changed: true, nodes: output.map((item) => item.node) };
+}
+
+// visio/edit-text-ranges.ts
+async function replaceScopedTextRanges(pkg, pagePaths, roots, document, edit, check) {
+  const shape = localTextTarget(roots.get(edit.pageId), document, edit.shapeId, check);
+  if (children2(shape, "Section").some((section) => attribute2(section, "N") === "Field"))
+    fail("UNSUPPORTED_TEXT_RANGE", "Text range editing of shapes with fields is unsupported.");
+  const texts = children2(shape, "Text");
+  if (texts.length !== 1)
+    fail("UNSUPPORTED_TEXT_RANGE", "Range editing requires one existing local Text element.");
+  const text = texts[0];
+  if (Array.from(text.childNodes).some((node) => ![3, 4].includes(node.nodeType))) {
+    const characters = effectiveFormattingRows(shape, document, "Character"), paragraphs = effectiveFormattingRows(shape, document, "Paragraph");
+    assertFormattingText(shape, characters, paragraphs);
+  }
+  if (Array.from(text.childNodes).some(
+    (node) => node.nodeType === 1 && node.localName === "fld"
+  ))
+    fail("UNSUPPORTED_TEXT_RANGE", "Text range editing of fields is unsupported.");
+  let preceding = "";
+  for (const node of Array.from(text.childNodes)) {
+    if (node.nodeType === 3 || node.nodeType === 4) preceding += node.nodeValue ?? "";
+    else {
+      const marker2 = node;
+      if (marker2.localName === "pp" && preceding && !preceding.endsWith("\n") || marker2.localName === "tp" && attribute2(marker2, "IX") !== "0")
+        fail(
+          "UNSUPPORTED_TEXT_RANGE",
+          "Noncanonical paragraph or tab marker placement cannot be edited."
+        );
+    }
+  }
+  const plan = textRangeNodes(text, edit);
+  if (!plan.changed) return false;
+  await assertFormattingDependencies(
+    pkg,
+    pagePaths,
+    roots,
+    edit.pageId,
+    shape,
+    /* @__PURE__ */ new Map([["TheText", text]]),
+    check
+  );
+  check();
+  while (text.firstChild) text.removeChild(text.firstChild);
+  for (const node of plan.nodes) text.appendChild(node);
+  return true;
+}
+
+// visio/basic-shapes.ts
+var VISIO_BASIC_SHAPES = [
+  "rectangle",
+  "square",
+  "triangle",
+  "right-triangle",
+  "pentagon",
+  "hexagon",
+  "octagon",
+  "star",
+  "diamond",
+  "rounded-rectangle",
+  "cross",
+  "parallelogram",
+  "trapezoid",
+  "can",
+  "cube",
+  "chevron"
+];
+var isVisioBasicShape = (value) => VISIO_BASIC_SHAPES.includes(value);
+function fit(points) {
+  const xs = points.map(([x]) => x), ys = points.map(([, y]) => y);
+  const left = Math.min(...xs), bottom = Math.min(...ys);
+  const width = Math.max(...xs) - left, height = Math.max(...ys) - bottom;
+  return points.map(([x, y]) => [(x - left) / width, (y - bottom) / height]);
+}
+function polygon(count, inner) {
+  const steps = inner === void 0 ? count : count * 2;
+  return fit(
+    Array.from({ length: steps }, (_, index) => {
+      const radius = inner !== void 0 && index % 2 ? inner : 1;
+      const angle = Math.PI / 2 + index * 2 * Math.PI / steps;
+      return [radius * Math.cos(angle), radius * Math.sin(angle)];
+    })
+  );
+}
+function arc(cy, ry, from, to) {
+  const segments = 12;
+  return Array.from({ length: segments + 1 }, (_, index) => {
+    const angle = from + (to - from) * index / segments;
+    return [0.5 + 0.5 * Math.cos(angle), cy + ry * Math.sin(angle)];
+  });
+}
+var box = [
+  [0, 0],
+  [1, 0],
+  [1, 1],
+  [0, 1]
+];
+var LID = 0.2;
+var CUT = 1 / (2 + Math.SQRT2);
+var OUTLINES = {
+  rectangle: { paths: [box] },
+  square: { paths: [box] },
+  triangle: {
+    paths: [
+      [
+        [0, 0],
+        [1, 0],
+        [0.5, 1]
+      ]
+    ]
+  },
+  "right-triangle": {
+    paths: [
+      [
+        [0, 0],
+        [1, 0],
+        [0, 1]
+      ]
+    ]
+  },
+  pentagon: { paths: [polygon(5)] },
+  hexagon: {
+    paths: [
+      [
+        [0.25, 0],
+        [0.75, 0],
+        [1, 0.5],
+        [0.75, 1],
+        [0.25, 1],
+        [0, 0.5]
+      ]
+    ]
+  },
+  octagon: {
+    paths: [
+      [
+        [CUT, 0],
+        [1 - CUT, 0],
+        [1, CUT],
+        [1, 1 - CUT],
+        [1 - CUT, 1],
+        [CUT, 1],
+        [0, 1 - CUT],
+        [0, CUT]
+      ]
+    ]
+  },
+  star: { paths: [polygon(5, 0.382)] },
+  diamond: {
+    paths: [
+      [
+        [0.5, 0],
+        [1, 0.5],
+        [0.5, 1],
+        [0, 0.5]
+      ]
+    ]
+  },
+  "rounded-rectangle": { paths: [box], rounding: 0.15 },
+  cross: {
+    paths: [
+      [
+        [1 / 3, 0],
+        [2 / 3, 0],
+        [2 / 3, 1 / 3],
+        [1, 1 / 3],
+        [1, 2 / 3],
+        [2 / 3, 2 / 3],
+        [2 / 3, 1],
+        [1 / 3, 1],
+        [1 / 3, 2 / 3],
+        [0, 2 / 3],
+        [0, 1 / 3],
+        [1 / 3, 1 / 3]
+      ]
+    ]
+  },
+  parallelogram: {
+    paths: [
+      [
+        [0, 0],
+        [0.75, 0],
+        [1, 1],
+        [0.25, 1]
+      ]
+    ]
+  },
+  trapezoid: {
+    paths: [
+      [
+        [0, 0],
+        [1, 0],
+        [0.75, 1],
+        [0.25, 1]
+      ]
+    ]
+  },
+  can: {
+    paths: [
+      // The body: down the left side, round the front of the base, up the right side and
+      // back along the front of the lid.
+      [...arc(LID / 2, LID / 2, Math.PI, 2 * Math.PI), ...arc(1 - LID / 2, LID / 2, 0, -Math.PI)],
+      // The lid, drawn over the body.
+      arc(1 - LID / 2, LID / 2, 0, 2 * Math.PI).slice(0, -1)
+    ]
+  },
+  cube: {
+    paths: [
+      [
+        [0, 0],
+        [0.75, 0],
+        [0.75, 0.75],
+        [0, 0.75]
+      ],
+      [
+        [0, 0.75],
+        [0.75, 0.75],
+        [1, 1],
+        [0.25, 1]
+      ],
+      [
+        [0.75, 0],
+        [1, 0.25],
+        [1, 1],
+        [0.75, 0.75]
+      ]
+    ]
+  },
+  chevron: {
+    paths: [
+      [
+        [0, 0],
+        [0.75, 0],
+        [1, 0.5],
+        [0.75, 1],
+        [0, 1],
+        [0.25, 0.5]
+      ]
+    ]
+  }
+};
+function visioBasicShapeOutline(shape) {
+  return OUTLINES[shape];
+}
+
+// visio/edit-text-range-commands.ts
+var invalidXmlText = /[\u0000-\u0008\u000b\u000c\u000d\u000e-\u001f\ufffe\uffff]|[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/u;
+function textRangeBoundary(text, offset) {
+  return !(offset > 0 && offset < text.length && /[\ud800-\udbff]/.test(text[offset - 1]) && /[\udc00-\udfff]/.test(text[offset]));
+}
+function snapshotTextRanges(edit, consume) {
+  let characters = 0;
+  const text = (value) => {
+    if (typeof value !== "string" || invalidXmlText.test(value))
+      fail("INVALID_EDIT_TEXT", "Range replacement requires valid XML text.");
+    characters += value.length;
+    if (characters > 1e6)
+      fail("LIMIT_EDIT_TEXT", "Range replacement text exceeds input limits.");
+    return consume ? consume(value) : value;
+  };
+  const pageId = edit.pageId, shapeId = edit.shapeId;
+  if ([pageId, shapeId].some((id) => typeof id !== "string" || !id || id.length > 256))
+    fail("INVALID_EDIT", "Invalid text range target.");
+  const expectedText = text(edit.expectedText), original = edit.ranges;
+  if (!Array.isArray(original)) fail("INVALID_EDIT", "Text ranges require an array.");
+  const length = original.length;
+  if (!Number.isSafeInteger(length) || length < 1 || length > 1e4)
+    fail("LIMIT_EDITS", "Range replacement requires 1-10000 ranges.");
+  const ranges = [];
+  let end = 0, output = expectedText.length;
+  for (let index = 0; index < length; index++) {
+    const input = original[index], start = input.start, nextEnd = input.end, replacement = text(input.text);
+    if (!Number.isSafeInteger(start) || !Number.isSafeInteger(nextEnd) || start < end || nextEnd <= start || nextEnd > expectedText.length || !textRangeBoundary(expectedText, start) || !textRangeBoundary(expectedText, nextEnd))
+      fail("INVALID_EDIT", "Text ranges require ascending nonoverlapping UTF16 scalar boundaries.");
+    if (replacement.includes("\n") || expectedText.slice(start, nextEnd).includes("\n"))
+      fail("UNSUPPORTED_TEXT_RANGE", "Range replacement across paragraph breaks is unsupported.");
+    ranges.push({ start, end: nextEnd, text: replacement });
+    end = nextEnd;
+    output += replacement.length - (nextEnd - start);
+  }
+  if (output > 1e6) fail("LIMIT_EDIT_TEXT", "Range replacement output exceeds limits.");
+  return { type: "replace-text-ranges", pageId, shapeId, expectedText, ranges };
+}
+
 // visio/resize-anchor.ts
 function snapshotResizeAnchor(value) {
   if (value === void 0) return void 0;
@@ -17782,7 +18194,7 @@ function snapshotFormatting(edit) {
 }
 
 // visio/edit-commands.ts
-var isVisioPageEdit = (edit) => edit.type === "insert-page" || edit.type === "reorder-page" || edit.type === "rename-page" || edit.type === "delete-page";
+var isVisioPageEdit = (edit) => edit.type === "insert-page" || edit.type === "reorder-page" || edit.type === "rename-page" || edit.type === "delete-page" || edit.type === "set-page-size";
 function geometryChangedCells(edit) {
   if (edit.type === "create-line")
     return [
@@ -17840,6 +18252,13 @@ function snapshotVisioEdits(edits, maxEdits, maxText) {
     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 === "set-page-size")
+      return {
+        type: edit.type,
+        pageId: edit.pageId,
+        width: numeric5(edit.width, true),
+        height: numeric5(edit.height, true)
+      };
     if (edit.type === "reorder-page") {
       if (!Number.isSafeInteger(edit.index) || edit.index < 0 || edit.index > 1e6)
         fail("INVALID_EDIT", "Page order requires a bounded zero-based integer index.");
@@ -17862,6 +18281,7 @@ function snapshotVisioEdits(edits, maxEdits, maxText) {
     const target = { pageId: edit.pageId, shapeId: edit.shapeId };
     if (edit.type === "replace-plain-text")
       return { ...target, type: edit.type, text: text(edit.text) };
+    if (edit.type === "replace-text-ranges") return snapshotTextRanges(edit, text);
     if (isVisioFormatEdit(edit)) return snapshotFormatting(edit);
     if (edit.type === "reorder-shape") {
       if (!["front", "back", "forward", "backward"].includes(edit.order))
@@ -17888,7 +18308,10 @@ function snapshotVisioEdits(edits, maxEdits, maxText) {
         return { ...target, type: edit.type, beginX, beginY, endX, endY };
       }
       case "create-rectangle":
-      case "create-ellipse":
+      case "create-ellipse": {
+        const shape = edit.type === "create-rectangle" ? edit.shape : void 0;
+        if (shape !== void 0 && !isVisioBasicShape(shape))
+          fail("INVALID_EDIT", "Unknown basic shape.");
         return {
           ...target,
           type: edit.type,
@@ -17896,8 +18319,10 @@ function snapshotVisioEdits(edits, maxEdits, maxText) {
           y: numeric5(edit.y),
           width: numeric5(edit.width, true),
           height: numeric5(edit.height, true),
-          ...edit.text === void 0 ? {} : { text: text(edit.text) }
+          ...edit.text === void 0 ? {} : { text: text(edit.text) },
+          ...shape === void 0 ? {} : { shape }
         };
+      }
       case "rotate-shape":
         return { ...target, type: edit.type, angle: numeric5(edit.angle) };
       case "flip-shape":
@@ -18311,24 +18736,25 @@ function createRectangle(root2, document, edit) {
   }
   const doc = root2.ownerDocument;
   const node = (name) => doc.createElementNS(root2.namespaceURI, name);
-  const section = node("Section");
-  section.setAttribute("N", "Geometry");
-  section.setAttribute("IX", "0");
-  for (const [index, [x, y]] of [
-    [0, 0],
-    [1, 0],
-    [1, 1],
-    [0, 1],
-    [0, 0]
-  ].entries()) {
-    const row = node("Row");
-    row.setAttribute("IX", String(index + 1));
-    row.setAttribute("T", index ? "RelLineTo" : "RelMoveTo");
-    setCell(row, "X", x);
-    setCell(row, "Y", y);
-    section.appendChild(row);
+  const outline = visioBasicShapeOutline(
+    edit.type === "create-rectangle" ? edit.shape ?? "rectangle" : "rectangle"
+  );
+  if (outline.rounding)
+    setCell(shape, "Rounding", outline.rounding * Math.min(edit.width, edit.height));
+  for (const [sectionIndex, points] of outline.paths.entries()) {
+    const section = node("Section");
+    section.setAttribute("N", "Geometry");
+    section.setAttribute("IX", String(sectionIndex));
+    for (const [index, [x, y]] of [...points, points[0]].entries()) {
+      const row = node("Row");
+      row.setAttribute("IX", String(index + 1));
+      row.setAttribute("T", index ? "RelLineTo" : "RelMoveTo");
+      setCell(row, "X", x);
+      setCell(row, "Y", y);
+      section.appendChild(row);
+    }
+    shape.appendChild(section);
   }
-  shape.appendChild(section);
   const text = node("Text");
   text.appendChild(doc.createTextNode(encodeVisioPlainText(edit.text ?? "")));
   shape.appendChild(text);
@@ -20560,6 +20986,145 @@ function addReplacementPage(pagesPart, pages, rels, types, pagePaths, parts, dir
   );
 }
 
+// visio/edit-page-size.ts
+function constant(node, length) {
+  if (!node || node.hasAttribute("E") || attribute2(node, "F") === "Inh")
+    fail("EDIT_UNSUPPORTED_PAGE_SIZE", "A valid explicit page size or mode cache is required.");
+  const value = visioFormulaCachedValue(attribute2(node, "V") ?? "", attribute2(node, "U"));
+  if (!Number.isFinite(value.value) || !["scalar", ...length ? ["length"] : []].includes(value.unit))
+    fail("EDIT_UNSUPPORTED_PAGE_SIZE", "Page size or mode has incompatible units.");
+  const formula = executableCellFormula(attribute2(node, "F"));
+  if (formula) {
+    const analysis = analyzeVisioFormula(formula);
+    if (analysis.guarded || analysis.dynamic || analysis.references.length || analysis.unsupportedFunctions.length)
+      fail("EDIT_PROTECTED_CELL", "Protected or dependent page settings cannot be overwritten.");
+    const result = evaluateVisioFormula(
+      formula,
+      () => fail("EDIT_PROTECTED_CELL", "Unsupported page dependency.")
+    );
+    if (result.value !== value.value || !["scalar", ...length ? ["length"] : []].includes(result.unit))
+      fail("EDIT_PROTECTED_CELL", "Page setting formula cache cannot be proven.");
+  }
+  return value.value;
+}
+var escape3 = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function assertDependencies(roots, pagesPart, pages, pagePaths, pageId, changed, check) {
+  const page = children2(pages, "Page").find((node) => attribute2(node, "ID") === pageId);
+  const targetNames = new Set(
+    ["Name", "NameU"].map((name) => attribute2(page, name)?.toLowerCase())
+  );
+  const otherNames = children2(pages, "Page").filter((node) => node !== page).flatMap((node) => ["Name", "NameU"].map((name) => attribute2(node, name))).filter((name) => !!name && !targetNames.has(name.toLowerCase()));
+  const cells4 = changed.map(escape3).join("|");
+  const reference = new RegExp(`(?:^|[^a-z0-9_.])(?:${cells4})(?:$|[^a-z0-9_.])`, "i");
+  const other = otherNames.length ? new RegExp(
+    `Pages\\[(?:${otherNames.map(escape3).join("|")})\\]!(?:ThePage!)?(?:${cells4})(?![a-z0-9_.])`,
+    "gi"
+  ) : void 0;
+  const paths = new Map([...pagePaths].map(([id, path]) => [path, id]));
+  for (const [path, root2] of roots)
+    for (const node of [root2, ...Array.from(root2.getElementsByTagName("*"))]) {
+      check();
+      const formula = executableCellFormula(attribute2(node, "F"));
+      if (!formula) continue;
+      let code = unquotedVisioFormula(formula);
+      const name = attribute2(node, "N") ?? "";
+      if (inertDoubleClickFormula(name, formula)) continue;
+      const owner = node.parentNode, container = owner?.parentNode;
+      const ownerId = attribute2(owner ?? void 0, "ID");
+      const connected = ownerId && /^[1-9]\d{0,9}$/.test(ownerId) && owner?.localName === "Shape" && owner.namespaceURI === root2.namespaceURI && (!attribute2(owner, "Type") || attribute2(owner, "Type") === "Shape") && !owner.hasAttribute("Master") && !owner.hasAttribute("MasterShape") && !children2(owner, "Shapes").length && ["BeginX", "BeginY", "EndX", "EndY"].every(
+        (name2) => children2(owner, "Cell").filter((cell) => attribute2(cell, "N") === name2).length === 1
+      ) && container?.localName === "Shapes" && container.parentNode === root2 && children2(root2, "Connects").some(
+        (connections2) => children2(connections2, "Connect").some(
+          (connection) => attribute2(connection, "FromSheet") === ownerId
+        )
+      );
+      const nativeGlue = paths.has(path) && connected && node.localName === "Cell" && node.namespaceURI === root2.namespaceURI && (/^(BeginX|BeginY|EndX|EndY)$/.test(name) && /^\s*_WALKGLUE\((?:BegTrigger,EndTrigger|EndTrigger,BegTrigger),WalkPreference\)\s*$/i.test(
+        code
+      ) || /^(BegTrigger|EndTrigger)$/.test(name) && /^\s*_XFTRIGGER\(Sheet\.[1-9]\d*!EventXFMod\)\s*$/i.test(code));
+      let dynamic2 = false;
+      if (!nativeGlue) {
+        try {
+          dynamic2 = analyzeVisioFormula(
+            mapVisioFormulaSyntax(
+              formula,
+              (part) => (other ? part.replace(other, "0") : part).replace(/Pages\[[^\]]+\]!/gi, "").replace(/ThePage!/gi, "")
+            )
+          ).dynamic;
+        } catch {
+          dynamic2 = true;
+        }
+      }
+      if (dynamic2)
+        fail(
+          "EDIT_UNSUPPORTED_PAGE_SIZE_DEPENDENCY",
+          "Dynamic or unknown page-size dependencies cannot be safely refreshed."
+        );
+      let local = paths.get(path);
+      if (path === pagesPart) {
+        let ancestor = node;
+        while (ancestor && ancestor.localName !== "Page")
+          ancestor = ancestor.parentNode;
+        local = ancestor ? attribute2(ancestor, "ID") : void 0;
+      }
+      if (other) code = code.replace(other, "0");
+      if (!reference.test(code)) continue;
+      if (local && local !== pageId && !/\bPages\[/i.test(code)) continue;
+      fail(
+        "EDIT_UNSUPPORTED_PAGE_SIZE_DEPENDENCY",
+        "Page-size formula caches cannot be safely refreshed."
+      );
+    }
+}
+async function setVisioPageSize(pkg, pagesPart, pages, pagePaths, dirty, command2, check) {
+  const page = children2(pages, "Page").find((node) => attribute2(node, "ID") === command2.pageId);
+  if (!page) fail("EDIT_TARGET_NOT_FOUND", "Page does not exist.");
+  if (children2(page, "PageSheet").length !== 1)
+    fail("EDIT_UNSUPPORTED_PAGE_SIZE", "One explicit PageSheet is required.");
+  const sheet = child(page, "PageSheet"), cells4 = uniqueFormattingCells(sheet);
+  for (const name of [
+    "PageWidth",
+    "PageHeight",
+    "PageScale",
+    "DrawingScale",
+    "DrawingSizeType",
+    "DrawingResizeType"
+  ])
+    if (!cells4.has(name) && [...cells4.keys()].some((key2) => key2.toLowerCase() === name.toLowerCase()))
+      fail("EDIT_AMBIGUOUS_CELL", "Page settings require canonical cell names.");
+  const pageScale = constant(cells4.get("PageScale"), true), drawingScale = constant(cells4.get("DrawingScale"), true);
+  if (pageScale <= 0 || drawingScale <= 0)
+    fail("EDIT_UNSUPPORTED_PAGE_SIZE", "Page and drawing scales must be positive.");
+  const width = constant(cells4.get("PageWidth"), true), height = constant(cells4.get("PageHeight"), true);
+  const size = constant(cells4.get("DrawingSizeType"), false);
+  const resize = cells4.has("DrawingResizeType") ? constant(cells4.get("DrawingResizeType"), false) : void 0;
+  if (width <= 0 || height <= 0 || ![0, 1, 2, 3, 4].includes(size) || resize !== void 0 && ![0, 1, 2].includes(resize))
+    fail("EDIT_UNSUPPORTED_PAGE_SIZE", "Page dimensions or size modes are unsupported.");
+  const targetWidth = command2.width === width * (pageScale / drawingScale) ? width : command2.width * drawingScale / pageScale, targetHeight = command2.height === height * (pageScale / drawingScale) ? height : command2.height * drawingScale / pageScale;
+  if (![targetWidth, targetHeight].every(
+    (value) => Number.isFinite(value) && value > 0 && value <= 1e6
+  ))
+    fail("INVALID_PAGE_SIZE", "Converted drawing-page dimensions exceed limits.");
+  const values = /* @__PURE__ */ new Map([
+    ["PageWidth", targetWidth],
+    ["PageHeight", targetHeight],
+    ["DrawingSizeType", 3],
+    ["DrawingResizeType", 0]
+  ]);
+  const changed = [...values.keys()].filter(
+    (name) => name === "PageWidth" ? width !== targetWidth : name === "PageHeight" ? height !== targetHeight : name === "DrawingSizeType" ? size !== 3 : resize !== 0
+  );
+  if (!changed.length) return;
+  const roots = await editableVisioPageRoots(pkg, pagesPart, pages, pagePaths, dirty, check);
+  for (const path of pkg.paths())
+    if (/^visio\/.*\.xml$/i.test(path) && !roots.has(path)) {
+      check();
+      roots.set(path, dirty.get(path) ?? await pkg.readXml(path));
+    }
+  assertDependencies(roots, pagesPart, pages, pagePaths, command2.pageId, changed, check);
+  for (const name of changed) setCell(sheet, name, values.get(name));
+  dirty.set(pagesPart, pages);
+}
+
 // visio/edit-pages.ts
 var officeRel2 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
 var pageType2 = "http://schemas.microsoft.com/visio/2010/relationships/page";
@@ -20595,6 +21160,10 @@ async function editVsdxPages(original, pkg, parts, commands, limits, maxOutput,
   for (const command2 of commands) {
     check();
     const existing = children2(pages, "Page");
+    if (command2.type === "set-page-size") {
+      await setVisioPageSize(pkg, pagesPart, pages, pagePaths, dirty, command2, check);
+      continue;
+    }
     if (command2.type === "delete-page") {
       await deleteVisioPage(
         pkg,
@@ -20698,8 +21267,10 @@ async function editVsdxPages(original, pkg, parts, commands, limits, maxOutput,
       fail("LIMIT_EDIT_OUTPUT", "Saved package exceeds output limit.");
     return { bytes: original, changedParts: [], diagnostics: [] };
   }
-  await updatePageAppProperties(pkg, pages, priorCount, dirty, limits, check);
-  await recalculatePageFormulas(pkg, pagesPart, pages, pagePaths, dirty, check);
+  if (commands.some((command2) => command2.type !== "set-page-size")) {
+    await updatePageAppProperties(pkg, pages, priorCount, dirty, limits, check);
+    await recalculatePageFormulas(pkg, pagesPart, pages, pagePaths, dirty, check);
+  }
   if ((/* @__PURE__ */ new Set([...parts.keys(), ...dirty.keys()])).size > limits.maxEntries)
     fail("LIMIT_ENTRIES", "Page insertion exceeds package entry limit.");
   let total = [...parts.values()].reduce((sum, bytes2) => sum + bytes2.length, 0), nodes = 0;
@@ -20727,8 +21298,8 @@ async function editVsdxPages(original, pkg, parts, commands, limits, maxOutput,
     changedParts: [.../* @__PURE__ */ new Set([...removed, ...dirty.keys()])],
     diagnostics: [
       {
-        code: "edit-pages-experimental",
-        message: "Page metadata and supported local numeric page-dependent caches were updated. Inherited, string and background-render-context formulas remain unsupported."
+        code: commands.every((command2) => command2.type === "set-page-size") ? "edit-page-size-experimental" : "edit-pages-experimental",
+        message: commands.every((command2) => command2.type === "set-page-size") ? "Fixed custom drawing-page dimensions were updated. Shape positions and printer settings were retained; affected page-size formula caches remain unsupported." : "Page metadata and supported local numeric page-dependent caches were updated. Inherited, string and background-render-context formulas remain unsupported."
       }
     ]
   };
@@ -21557,12 +22128,12 @@ async function editVsdx(input, edits, options = {}) {
   const dirty = /* @__PURE__ */ new Map();
   const roots = /* @__PURE__ */ new Map();
   const geometryCommands = commands.filter(
-    (command2) => command2.type !== "replace-plain-text" && command2.type !== "reorder-shape" && command2.type !== "duplicate-shapes" && command2.type !== "paste-shapes" && !isVisioFormatEdit(command2)
+    (command2) => command2.type !== "replace-plain-text" && command2.type !== "replace-text-ranges" && command2.type !== "reorder-shape" && command2.type !== "duplicate-shapes" && command2.type !== "paste-shapes" && !isVisioFormatEdit(command2)
   );
   let document;
   let masterMovePins = emptyMasterMoveProof();
   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"
+    (command2) => command2.type === "replace-plain-text" || command2.type === "replace-text-ranges" || isVisioFormatEdit(command2) || command2.type === "reorder-shape" || command2.type === "duplicate-shapes" || command2.type === "paste-shapes"
   )) {
     for (const [pageId, path2] of pages) {
       const sourceRoot = await visioXml(pkg, path2, "PageContents");
@@ -21609,8 +22180,8 @@ async function editVsdx(input, edits, options = {}) {
       root2 = sourceRoot.ownerDocument.cloneNode(true).documentElement;
       roots.set(command2.pageId, root2);
     }
-    if (command2.type === "replace-plain-text") {
-      if (await replaceScopedPlainText(pkg, new Set(pages.values()), roots, document, command2, check)) {
+    if (command2.type === "replace-plain-text" || command2.type === "replace-text-ranges") {
+      if (await (command2.type === "replace-plain-text" ? replaceScopedPlainText(pkg, new Set(pages.values()), roots, document, command2, check) : replaceScopedTextRanges(pkg, new Set(pages.values()), roots, document, command2, check))) {
         dirty.set(path, root2);
         textChanged = true;
       }
@@ -22057,6 +22628,7 @@ function trimVisioArrowLine(path, start, end, beginExtension = 0) {
   return `M ${point2(start)}${base > start ? ` L ${point2(base)}` : ""} L ${point2(length - end)}`;
 }
 
+exports.VISIO_BASIC_SHAPES = VISIO_BASIC_SHAPES;
 exports.VISIO_CLIPBOARD_MAGIC = VISIO_CLIPBOARD_MAGIC;
 exports.VISIO_CLIPBOARD_MAX_CHARS = VISIO_CLIPBOARD_MAX_CHARS;
 exports.VISIO_EMF_ADMISSION_LIMITS = VISIO_EMF_ADMISSION_LIMITS;
@@ -22077,6 +22649,7 @@ exports.evaluateVisioFormula = evaluateVisioFormula;
 exports.getVisioPageLayers = getVisioPageLayers;
 exports.inspectVisioEmfAdmission = inspectVisioEmfAdmission;
 exports.inspectVisioRasterImage = inspectVisioRasterImage;
+exports.isVisioBasicShape = isVisioBasicShape;
 exports.layoutVisioFilledArrowLine = layoutVisioFilledArrowLine;
 exports.loadVisio = loadVisio;
 exports.parseLegacyVsd = parseLegacyVsd;
@@ -22087,6 +22660,7 @@ exports.sanitizeVisioForeignVectorTree = sanitizeVisioForeignVectorTree;
 exports.serializeVisioClipboard = serializeVisioClipboard;
 exports.trimVisioArrowLine = trimVisioArrowLine;
 exports.validateVisioForeignVector = validateVisioForeignVector;
+exports.visioBasicShapeOutline = visioBasicShapeOutline;
 exports.visioFilledArrow = visioFilledArrow;
 exports.visioFormulaCachedValue = visioFormulaCachedValue;
 exports.visioOpenArrowExtent = visioOpenArrowExtent;