ooxml-core 1.2.1 → 1.3.0

package/dist/visio/ui/index.mjs

@@ -11,7 +11,8 @@ var eventKeys = [
   "document-error",
   "page-change",
   "zoom-change",
-  "shape-select"
+  "shape-select",
+  "selection-change"
 ];
 
 // visio/ui/demo-document.ts
@@ -322,6 +323,259 @@ function textSearchStatus(search) {
   return result + (search.indexTruncated ? " \xB7 Partial text index" : "");
 }
 
+// visio/package-common.ts
+var VisioPackageError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "VisioPackageError";
+  }
+  code;
+};
+function fail(code, message) {
+  throw new VisioPackageError(code, message);
+}
+new TextDecoder("utf-8", { fatal: true });
+var crcTable = Uint32Array.from({ length: 256 }, (_, value) => {
+  for (let i = 0; i < 8; i++) value = value & 1 ? 3988292384 ^ value >>> 1 : value >>> 1;
+  return value >>> 0;
+});
+function crc32(bytes, crc = 4294967295) {
+  for (const byte of bytes) crc = (crcTable[(crc ^ byte) & 255] ?? 0) ^ crc >>> 8;
+  return crc >>> 0;
+}
+function decodePath(path) {
+  try {
+    return decodeURIComponent(path);
+  } catch {
+    return fail("UNSAFE_PATH", "Invalid percent encoding in package path");
+  }
+}
+function safePath(path, directory = false) {
+  const decoded = decodePath(path);
+  if (/%(?:2f|5c)/i.test(path)) fail("UNSAFE_PATH", "Encoded path separators are unsupported");
+  if (/[\\:#?\u0000-\u001f\u007f]/.test(path) || /[\\:#?%\u0000-\u001f\u007f]/.test(decoded))
+    fail("UNSAFE_PATH", `Unsafe package path: ${path}`);
+  for (const candidate of [path, decoded]) {
+    const name = directory && candidate.endsWith("/") ? candidate.slice(0, -1) : candidate;
+    if (!name || name.split("/").some((part) => !part || part === "." || part === ".."))
+      fail("UNSAFE_PATH", `Unsafe package path: ${path}`);
+  }
+  return path;
+}
+
+// visio/edit-formatting-commands.ts
+var isVisioFormatEdit = (edit) => edit.type === "format-text" || edit.type === "format-shape";
+function snapshotFormatting(edit) {
+  const result = { 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)
+      fail("INVALID_EDIT", "Formatting point size is outside supported limits.");
+    return value;
+  };
+  const color = (value, allowNone = false) => {
+    if (typeof value !== "string" || !(allowNone && value === "none") && !/^#[0-9a-f]{6}$/i.test(value))
+      fail("INVALID_EDIT", "Formatting colors require six hexadecimal digits.");
+    return value.toLowerCase();
+  };
+  if (edit.type === "format-text" && result.type === "format-text") {
+    if (edit.fontSize !== void 0) result.fontSize = points(edit.fontSize, 1, 1e3);
+    if (edit.fontColor !== void 0) result.fontColor = color(edit.fontColor);
+    if (edit.indentLeft !== void 0) result.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))
+        fail("INVALID_EDIT", "Invalid font family.");
+      result.fontFamily = edit.fontFamily;
+    }
+    for (const name of ["bold", "italic", "underline", "strikethrough", "bullets"]) {
+      if (edit[name] === void 0) continue;
+      if (typeof edit[name] !== "boolean") fail("INVALID_EDIT", "Text styles require booleans.");
+      result[name] = edit[name];
+    }
+    if (edit.horizontalAlign !== void 0) {
+      if (!["left", "center", "right", "justify"].includes(edit.horizontalAlign))
+        fail("INVALID_EDIT", "Invalid horizontal alignment.");
+      result.horizontalAlign = edit.horizontalAlign;
+    }
+    if (edit.verticalAlign !== void 0) {
+      if (!["top", "middle", "bottom"].includes(edit.verticalAlign))
+        fail("INVALID_EDIT", "Invalid vertical alignment.");
+      result.verticalAlign = edit.verticalAlign;
+    }
+  } else if (edit.type === "format-shape" && result.type === "format-shape") {
+    if (edit.fillColor !== void 0) result.fillColor = color(edit.fillColor, true);
+    if (edit.lineColor !== void 0) result.lineColor = color(edit.lineColor);
+    if (edit.lineWeight !== void 0) result.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)) fail("INVALID_EDIT", "Paint patterns require integers.");
+      result[name] = value;
+    }
+    for (const name of ["lineTransparency", "fillTransparency"])
+      if (edit[name] !== void 0) result[name] = Math.round(points(edit[name], 0, 100) * 2) / 2;
+    if (edit.fillBackgroundColor !== void 0)
+      result.fillBackgroundColor = color(edit.fillBackgroundColor);
+    if (result.fillColor === "none" && result.fillPattern !== void 0 && result.fillPattern !== 0)
+      fail("INVALID_EDIT", "No fill conflicts with a visible fill pattern.");
+  }
+  if (Object.keys(result).length === 3)
+    fail("INVALID_EDIT", "Formatting requires at least one property.");
+  return result;
+}
+
+// visio/edit-duplicate-commands.ts
+function snapshotDuplicateShapes(edit) {
+  if (!Array.isArray(edit.copies) || !edit.copies.length || edit.copies.length > 1e3)
+    fail("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
+  ))
+    fail("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)
+      fail("INVALID_EDIT", "Duplicate shape IDs require canonical unsigned integers.");
+    return value;
+  };
+  const copies = edit.copies.map((copy) => {
+    if (!copy || typeof copy !== "object") fail("INVALID_EDIT", "Invalid duplicate shape mapping.");
+    const shapeId = id(copy.shapeId), newShapeId = id(copy.newShapeId);
+    if (sources.has(shapeId) || targets.has(newShapeId))
+      fail("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)
+    fail("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)
+    fail("INVALID_CLIPBOARD", "Unsupported Visio clipboard format or version.");
+  const sourcePageId = clipboardId(value.sourcePageId), sourceDrawingScale = value.sourceDrawingScale;
+  if (!Number.isFinite(sourceDrawingScale) || sourceDrawingScale <= 0 || sourceDrawingScale > 1e6)
+    fail("INVALID_CLIPBOARD", "Invalid clipboard drawing ratio.");
+  let characters = 0;
+  const text = (input) => {
+    if (typeof input !== "string" || (characters += input.length) > VISIO_CLIPBOARD_MAX_CHARS)
+      fail("LIMIT_CLIPBOARD", "Clipboard XML exceeds bounded text limits.");
+    if (/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/.test(input))
+      fail("INVALID_CLIPBOARD", "Clipboard XML must contain well-formed Unicode.");
+    return input;
+  };
+  const list = (input, max) => {
+    if (!Array.isArray(input) || !input.length || input.length > max)
+      fail("INVALID_CLIPBOARD", "Invalid clipboard array length.");
+    return input;
+  };
+  const selectionIds = list(value.selectionIds, 1e3).map(clipboardId);
+  const shapes = list(value.shapes, 1e3).map((shape) => {
+    if (!shape || typeof shape !== "object") fail("INVALID_CLIPBOARD", "Invalid captured shape.");
+    return { shapeId: clipboardId(shape.shapeId), xml: text(shape.xml) };
+  });
+  const resources = list(value.resources, 64).map((resource) => {
+    const path = resource?.path;
+    if (!resource || typeof resource !== "object" || typeof path !== "string" || path.length > 1024 || !/^visio\/(?:document\.xml|_rels\/document\.xml\.rels|theme\/[^/]+\.(?:xml|rels)|theme\/_rels\/[^/]+\.rels)$/.test(
+      path
+    ))
+      fail("INVALID_CLIPBOARD", "Invalid clipboard resource path.");
+    return { path: text(safePath(path)), xml: text(resource.xml) };
+  });
+  if (new Set(selectionIds).size !== selectionIds.length || new Set(shapes.map((shape) => shape.shapeId)).size !== shapes.length || selectionIds.length !== shapes.length || selectionIds.some((id) => !shapes.some((shape) => shape.shapeId === id)) || new Set(resources.map((resource) => resource.path)).size !== resources.length)
+    fail("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((a, b) => a.path.localeCompare(b.path)),
+    pageContext: text(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((copy) => !clipboard.selectionIds.includes(copy.shapeId)))
+    fail("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/resize-anchor.ts
+function snapshotResizeAnchor(value) {
+  if (value === void 0) return void 0;
+  if (!value || typeof value !== "object") fail("INVALID_EDIT", "Invalid resize anchor.");
+  const { x, y } = value;
+  if (![0, 0.5, 1].includes(x) || ![0, 0.5, 1].includes(y))
+    fail("INVALID_EDIT", "Resize anchor coordinates must be 0, 0.5 or 1.");
+  return { x, y };
+}
+function visioAnchoredResizeGeometry(current, size, anchor) {
+  const [a, b, c, d, e, f] = current.transform;
+  const determinant = a * d - b * c;
+  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(a * a + b * b - 1) > 1e-8 || Math.abs(c * c + d * d - 1) > 1e-8 || Math.abs(a * c + b * d) > 1e-8)
+    return void 0;
+  const offsetX = current.pinX - e, offsetY = current.pinY - f;
+  const oldX = (d * offsetX - c * offsetY) / determinant;
+  const oldY = (-b * offsetX + a * 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 + a * deltaX + c * deltaY, pinY = current.pinY + b * deltaX + d * deltaY;
+  const matrix2 = [
+    a,
+    b,
+    c,
+    d,
+    pinX - a * locPinX - c * locPinY,
+    pinY - b * locPinX - d * locPinY
+  ];
+  return [pinX, pinY, locPinX, locPinY, ...matrix2].every(Number.isFinite) ? { pinX, pinY, locPinX, locPinY, transform: matrix2 } : void 0;
+}
+
 // visio/ui/edit-commands.ts
 function snapshotEdits(edits) {
   if (!Array.isArray(edits) || edits.length > 1e3)
@@ -330,6 +584,8 @@ function snapshotEdits(edits) {
   return edits.map((command) => {
     if (!command || typeof command.pageId !== "string" || !command.pageId || command.pageId.length > 256)
       throw new Error("Invalid edit command.");
+    if (command.type === "duplicate-shapes") return snapshotDuplicateShapes(command);
+    if (command.type === "paste-shapes") return snapshotPasteShapes(command);
     if (command.type === "reorder-page") {
       if (!Number.isSafeInteger(command.index) || command.index < 0 || command.index > 1e6)
         throw new Error("Invalid page order index.");
@@ -362,7 +618,23 @@ function snapshotEdits(edits) {
     if (typeof command.shapeId !== "string" || !command.shapeId || command.shapeId.length > 256)
       throw new Error("Invalid edit shape target.");
     const target = { pageId: command.pageId, shapeId: command.shapeId };
+    if (isVisioFormatEdit(command)) return snapshotFormatting(command);
     switch (command.type) {
+      case "create-text-box":
+        numbers(command.x, command.y, command.width, command.height);
+        return {
+          type: command.type,
+          ...target,
+          x: command.x,
+          y: command.y,
+          width: command.width,
+          height: command.height,
+          text: text(command.text)
+        };
+      case "reorder-shape":
+        if (!["front", "back", "forward", "backward"].includes(command.order))
+          throw new Error("Invalid shape order.");
+        return { ...target, type: command.type, order: command.order };
       case "create-line":
         numbers(command.beginX, command.beginY, command.endX, command.endY);
         return {
@@ -398,9 +670,17 @@ function snapshotEdits(edits) {
           x: command.x,
           y: command.y
         };
-      case "resize-shape":
+      case "resize-shape": {
         numbers(command.width, command.height);
-        return { type: command.type, ...target, width: command.width, height: command.height };
+        const anchor = snapshotResizeAnchor(command.anchor);
+        return {
+          type: command.type,
+          ...target,
+          width: command.width,
+          height: command.height,
+          ...anchor === void 0 ? {} : { anchor }
+        };
+      }
       case "create-rectangle":
       case "create-ellipse":
         numbers(command.x, command.y, command.width, command.height);
@@ -428,15 +708,6 @@ function editErrorMessage(error) {
 function isEditCancellation(error) {
   return !!error && typeof error === "object" && "name" in error && error.name === "AbortError";
 }
-new TextDecoder("utf-8", { fatal: true });
-var crcTable = Uint32Array.from({ length: 256 }, (_, value) => {
-  for (let i = 0; i < 8; i++) value = value & 1 ? 3988292384 ^ value >>> 1 : value >>> 1;
-  return value >>> 0;
-});
-function crc32(bytes, crc = 4294967295) {
-  for (const byte of bytes) crc = (crcTable[(crc ^ byte) & 255] ?? 0) ^ crc >>> 8;
-  return crc >>> 0;
-}
 
 // visio/foreign-vector-types.ts
 var VISIO_FOREIGN_VECTOR_LIMITS = Object.freeze({
@@ -1376,6 +1647,29 @@ function transform(x, y, localX, localY, angle, flipX = false, flipY = false) {
   return [a, b, c, d, x - a * localX - c * localY, y - b * localX - d * localY];
 }
 
+// visio/parser.ts
+function getVisioPageLayers(document, pageId) {
+  const result = [], seen = /* @__PURE__ */ new Set();
+  const pages = new Map(document.pages.map((page) => [page.id, page]));
+  let current = pages.get(pageId);
+  while (current && !seen.has(current.id)) {
+    seen.add(current.id);
+    result.push(current);
+    current = current.backgroundPageId === void 0 ? void 0 : pages.get(current.backgroundPageId);
+  }
+  return result.reverse();
+}
+
+// visio/visibility.ts
+var VISIO_VISIBILITY_LIMITS = Object.freeze({
+  maxShapes: 25e3,
+  maxDepth: 64,
+  maxLayers: 25e3,
+  maxMemberships: 1e5,
+  maxMembershipsPerShape: 1024,
+  maxLayerIdLength: 256
+});
+
 // visio/ui/foreign-vector-budget.ts
 var FOREIGN_VECTOR_SCENE_LIMITS = Object.freeze({
   maxNodes: 1e5,
@@ -1573,6 +1867,11 @@ function assertViewableDocument(model) {
     metadataBytes += value.length;
     if (metadataBytes > 1e6) throw new Error("The scene exceeds aggregate metadata limits.");
   };
+  if (model.fontFamilies !== void 0) {
+    if (!Array.isArray(model.fontFamilies) || model.fontFamilies.length > 1e4)
+      throw new Error("The scene has an invalid font family list.");
+    for (const family of model.fontFamilies) label(family, 1024);
+  }
   for (const diagnostic of model.diagnostics) {
     label(diagnostic.code, 256);
     label(diagnostic.message);
@@ -1618,7 +1917,9 @@ function assertViewableDocument(model) {
     member(shape.kind, ["shape", "group", "connector", "foreign"], "shape kind");
     if (shape.groupDisplayMode !== void 0)
       member(shape.groupDisplayMode, [0, 1, 2], "group display mode");
-    member(shape.text.horizontalAlign, ["left", "center", "right"], "text alignment");
+    member(shape.text.horizontalAlign, ["left", "center", "right", "justify"], "text alignment");
+    for (const key of ["bold", "italic", "underline", "strikethrough"])
+      if (shape.text[key] !== void 0) member(shape.text[key], [true, false], "text style");
     member(shape.text.verticalAlign, ["top", "middle", "bottom"], "text alignment");
     label(shape.name);
     label(shape.text.fontFamily, 1024);
@@ -1657,7 +1958,7 @@ function assertViewableDocument(model) {
       const dash = shape.style.lineDash;
       if (!Array.isArray(dash) || dash.length < 2 || dash.length > 6 || dash.length % 2 !== 0)
         throw new Error("The scene has an invalid normalized line dash.");
-      for (const value of dash) finite2(value, "line dash length", 0, 27);
+      for (const value of dash) finite2(value, "line dash length", 0, 40);
       if (!dash.some((value) => value > 0))
         throw new Error("The scene has an empty line dash pattern.");
     }
@@ -1672,6 +1973,21 @@ function assertViewableDocument(model) {
       throw new Error("The scene has an invalid normalized line cap.");
     finite2(shape.style.fillOpacity, "fill opacity", 0, 1);
     finite2(shape.style.lineOpacity, "line opacity", 0, 1);
+    if (shape.style.lineDashDotLength !== void 0)
+      finite2(shape.style.lineDashDotLength, "line dash dot length", 0, 1e6);
+    for (const name of [
+      "fillForegroundOpacity",
+      "fillBackgroundOpacity",
+      "lineColorOpacity"
+    ])
+      if (shape.style[name] !== void 0) finite2(shape.style[name], "source paint opacity", 0, 1);
+    if (shape.style.fillPatternIndex !== void 0) {
+      finite2(shape.style.fillPatternIndex, "source fill pattern", 0, 65535);
+      if (!Number.isInteger(shape.style.fillPatternIndex))
+        throw new Error("The scene has an invalid source fill pattern.");
+    }
+    if (shape.style.fillBackgroundColor !== void 0 && (typeof shape.style.fillBackgroundColor !== "string" || !/^#[0-9a-f]{6}$/i.test(shape.style.fillBackgroundColor)))
+      throw new Error("The scene has an invalid source fill background color.");
     if (shape.style.fillPattern) {
       const tile = shape.style.fillPattern;
       finite2(tile.width, "fill pattern width", 1 / 12, 1 / 12);
@@ -1694,6 +2010,8 @@ function assertViewableDocument(model) {
     if (!Array.isArray(shape.text.runs) || runCount + shape.text.runs.length > 1e5)
       throw new Error("The scene exceeds safe text run limits or has an invalid run list.");
     for (const run of shape.text.runs) {
+      if (run.strikethrough !== void 0)
+        member(run.strikethrough, [true, false], "strikethrough style");
       label(run.fontFamily, 1024);
       label(run.color, 256);
       if (run.opacity !== void 0) finite2(run.opacity, "text run opacity", 0, 1);
@@ -1866,10 +2184,16 @@ function copySnapshotScene(model) {
   const style = (source) => {
     const result = fields(source, [
       "fill",
+      "fillPatternIndex",
+      "fillForegroundOpacity",
+      "fillBackgroundColor",
+      "fillBackgroundOpacity",
       "lineColor",
       "lineWidth",
       "lineCap",
       "linePattern",
+      "lineDashDotLength",
+      "lineColorOpacity",
       "fillOpacity",
       "lineOpacity",
       "startArrow",
@@ -1948,6 +2272,10 @@ function copySnapshotScene(model) {
   const text = (source) => ({
     ...fields(source, [
       "plainText",
+      "bold",
+      "italic",
+      "underline",
+      "strikethrough",
       "backgroundColor",
       "backgroundOpacity",
       "opacity",
@@ -1965,7 +2293,8 @@ function copySnapshotScene(model) {
       ...fields(run, ["text", "fontFamily", "fontSize", "color", "opacity"]),
       bold: !!run.bold,
       italic: !!run.italic,
-      underline: !!run.underline
+      underline: !!run.underline,
+      ...run.strikethrough === void 0 ? {} : { strikethrough: !!run.strikethrough }
     })),
     ...source.paragraphs === void 0 ? {} : { paragraphs: list(source.paragraphs, "paragraphs", 5e4, paragraph) }
   });
@@ -1997,6 +2326,12 @@ function copySnapshotScene(model) {
   };
   return {
     format: "vsdx",
+    ...model.fontFamilies === void 0 ? {} : {
+      fontFamilies: list(model.fontFamilies, "font families", 1e4, (font) => {
+        if (typeof font !== "string" || font.length > 1024) throw invalid2();
+        return font;
+      })
+    },
     diagnostics: list(
       model.diagnostics,
       "diagnostics",
@@ -2051,6 +2386,7 @@ function visioPageEditToDrawing(page, edit) {
       return edit;
     case "create-rectangle":
     case "create-ellipse":
+    case "create-text-box":
       return {
         ...edit,
         x: coordinate(edit.x),
@@ -2098,6 +2434,103 @@ function visioNextShapeId(page) {
   return String(max + 1);
 }
 
+// visio/ui/formatting.ts
+function visioStyleFormattingShape(page, shapeId) {
+  const candidates = page.shapes.filter((shape2) => shape2.id === shapeId);
+  if (candidates.length !== 1) return void 0;
+  const shape = candidates[0];
+  if (shape.hidden || shape.masterId || shape.layerIds?.length || shape.children.length || !["shape", "connector"].includes(shape.kind) || shape.image || shape.foreignVector)
+    return void 0;
+  return shape;
+}
+function visioFormattingShape(page, shapeId) {
+  return visioStyleFormattingShape(page, shapeId);
+}
+function visioFontFamilies(document) {
+  return [...new Set(document.fontFamilies ?? [])].sort((left, right) => left.localeCompare(right));
+}
+function visioTextFormattingState(shapes) {
+  const common = (values) => values.length && values.every((value) => value === values[0]) ? values[0] : void 0;
+  const runs = shapes.flatMap(
+    (shape) => shape.text.runs.length ? shape.text.runs : [shape.text]
+  );
+  const styled = (key) => !!runs.length && runs.every((run) => !!run[key]);
+  const paragraphs = shapes.flatMap((shape) => shape.text.paragraphs ?? []);
+  const alignment = common(
+    shapes.flatMap(
+      (shape) => shape.text.paragraphs?.length ? shape.text.paragraphs.map((paragraph) => paragraph.horizontalAlign) : [shape.text.horizontalAlign]
+    )
+  );
+  return {
+    bold: styled("bold"),
+    italic: styled("italic"),
+    underline: styled("underline"),
+    strikethrough: styled("strikethrough"),
+    bullets: !!shapes.length && shapes.every(
+      (shape) => !!shape.text.paragraphs?.length && shape.text.paragraphs.every((paragraph) => !!paragraph.bullet)
+    ),
+    fontFamily: common(runs.map((run) => run.fontFamily)),
+    fontSize: common(runs.map((run) => run.fontSize)),
+    fontColor: common(runs.map((run) => run.color)),
+    horizontalAlign: alignment === "distributed" ? void 0 : alignment,
+    verticalAlign: common(shapes.map((shape) => shape.text.verticalAlign)),
+    canIndentDecrease: paragraphs.some((paragraph) => paragraph.indentLeft > 0)
+  };
+}
+function visioTextIndentCommand(page, shapeId, direction) {
+  const shape = visioFormattingShape(page, shapeId);
+  if (!shape || !["increase", "decrease"].includes(direction)) return void 0;
+  const paragraphs = shape.text.paragraphs ?? [];
+  const left = paragraphs[0]?.indentLeft ?? 0;
+  if (!Number.isFinite(left) || left < 0 || paragraphs.some((paragraph) => paragraph.indentLeft !== left))
+    return void 0;
+  const points = left * 72;
+  const indentLeft = Math.min(7200, Math.max(0, points + (direction === "increase" ? 18 : -18)));
+  return { type: "format-text", pageId: page.id, shapeId, indentLeft };
+}
+function visioTextFontStepCommand(page, shapeId, direction) {
+  const shape = visioFormattingShape(page, shapeId);
+  if (!shape || !["increase", "decrease"].includes(direction)) return void 0;
+  const sizes = shape.text.runs.length ? shape.text.runs.map((run) => run.fontSize) : [shape.text.fontSize];
+  const size = sizes[0];
+  if (!Number.isFinite(size) || sizes.some((value) => Math.abs(value - size) > 1e-10))
+    return void 0;
+  const current = size * 72;
+  if (current < 1 || current > 1e3) return void 0;
+  const steps = [6, 8, 9, 10, 11, 12, 14, 16, 18, 20, 24, 28, 32, 36, 48, 72];
+  const fontSize = direction === "increase" ? steps.find((value) => value > current + 1e-3) ?? Math.min(1e3, Math.ceil(current * 1.2)) : steps.reverse().find((value) => value < current - 1e-3) ?? Math.max(1, Math.floor(current / 1.2));
+  return { type: "format-text", pageId: page.id, shapeId, fontSize };
+}
+
+// visio/ui/shape-duplicate.ts
+function visioDuplicateCommand(page, shapeIds) {
+  if (!shapeIds.length || shapeIds.length > 1e3 || new Set(shapeIds).size !== shapeIds.length || shapeIds.some((id) => {
+    const shape = visioStyleFormattingShape(page, id);
+    return !shape || shape.kind !== "shape" || !(shape.width > 0) || !(shape.height > 0) || page.connectors.some(
+      (connection) => connection.fromShapeId === id || connection.toShapeId === id
+    );
+  }))
+    return void 0;
+  let next;
+  try {
+    next = Number(visioNextShapeId(page));
+  } catch {
+    return void 0;
+  }
+  if (next + shapeIds.length - 1 > 4294967295) return void 0;
+  const selected = new Set(shapeIds);
+  const mapping = new Map(
+    page.shapes.filter((shape) => selected.has(shape.id)).map((shape) => [shape.id, String(next++)])
+  );
+  return {
+    type: "duplicate-shapes",
+    pageId: page.id,
+    copies: shapeIds.map((shapeId) => ({ shapeId, newShapeId: mapping.get(shapeId) })),
+    offsetX: 0.33,
+    offsetY: -0.33
+  };
+}
+
 // visio/ui/fill-pattern-transform.ts
 function visioFillPatternTransform(world, pageHeight = 0) {
   const determinant = world[0] * world[3] - world[1] * world[2];
@@ -2157,4 +2590,816 @@ function visioQuarterTurnCommand(page, shapeId, direction) {
   };
 }
 
-export { DocumentHistory, EDIT_HISTORY_LIMITS, EMPTY_EDIT_STATE, EMPTY_TEXT_SEARCH, FOREIGN_VECTOR_SCENE_LIMITS, ForeignVectorBudget, MAX_INPUT_BYTES, TEXT_SEARCH_LIMITS, IDENTITY_AFFINE as VISIO_IDENTITY_TRANSFORM, assertShapeDetails, assertViewableDocument, compatibilityNotes, compatibilityText, composeAffine as composeVisioTransform, copySnapshotScene, demoDocument, editErrorMessage, eventKeys, indexDocumentText, inspectForeignVectorResource, isEditCancellation, propertyKeys, searchDocumentText, snapshotEdits, textSearchStatus, validateSearchQuery, visioFillPatternTransform, visioGradientInstances, visioLocalRotationShape, visioNextShapeId, visioPageEditToDrawing, visioPageInsertCommand, visioQuarterTurnCommand, visioRenderedGradientStopCount, visioRenderedGradientStops, visioRotationPreviewTransform, visioStraightLineHandles, visioStrokeGradient };
+// visio/ui/shape-order.ts
+function visioOrderingShape(page, shapeId) {
+  if (page.shapes.some(
+    (shape2) => shape2.kind !== "shape" || shape2.masterId || shape2.children.length || shape2.image || shape2.foreignVector
+  ))
+    return void 0;
+  const shape = page.shapes.find((candidate) => candidate.id === shapeId);
+  return shape && !shape.hidden && !shape.layerIds?.length ? shape : void 0;
+}
+
+// geometry/align-distribute.ts
+function usesSlideReference(elementCount, options) {
+  if (!options?.slideSize) {
+    return false;
+  }
+  return options.reference === "slide";
+}
+function resolveAlignReferenceBox(elements, options) {
+  if (elements.length === 0) {
+    return null;
+  }
+  if (usesSlideReference(elements.length, options)) {
+    return { minX: 0, minY: 0, maxX: options.slideSize.width, maxY: options.slideSize.height };
+  }
+  if (elements.length < 2) {
+    return null;
+  }
+  return {
+    minX: Math.min(...elements.map((e) => e.x)),
+    minY: Math.min(...elements.map((e) => e.y)),
+    maxX: Math.max(...elements.map((e) => e.x + e.width)),
+    maxY: Math.max(...elements.map((e) => e.y + e.height))
+  };
+}
+function alignElements(elements, edge, options) {
+  const result = /* @__PURE__ */ new Map();
+  const ref = resolveAlignReferenceBox(elements, options);
+  if (!ref) {
+    return result;
+  }
+  const { minX, minY, maxX, maxY } = ref;
+  const centerX = (minX + maxX) / 2;
+  const centerY = (minY + maxY) / 2;
+  for (const el of elements) {
+    switch (edge) {
+      case "left":
+        result.set(el.id, { x: minX });
+        break;
+      case "right":
+        result.set(el.id, { x: maxX - el.width });
+        break;
+      case "centerH":
+        result.set(el.id, { x: centerX - el.width / 2 });
+        break;
+      case "top":
+        result.set(el.id, { y: minY });
+        break;
+      case "bottom":
+        result.set(el.id, { y: maxY - el.height });
+        break;
+      case "middle":
+        result.set(el.id, { y: centerY - el.height / 2 });
+        break;
+    }
+  }
+  return result;
+}
+
+// visio/ui/shape-arrange.ts
+function distributeBoxes(boxes, axis) {
+  const horizontal = axis === "horizontal";
+  const start = (box2) => horizontal ? box2.x : -box2.y - box2.height;
+  const size = (box2) => horizontal ? box2.width : box2.height;
+  const center = (box2) => start(box2) + size(box2) / 2;
+  const sorted = [...boxes].sort((left, right) => center(left) - center(right));
+  const first = sorted[0], last = sorted.at(-1);
+  const total = sorted.reduce((sum, box2) => sum + size(box2), 0);
+  const gap = (start(last) + size(last) - start(first) - total) / (sorted.length - 1);
+  let cursor = start(first);
+  const positions = /* @__PURE__ */ new Map();
+  for (const box2 of sorted) {
+    positions.set(box2.id, horizontal ? { x: cursor } : { y: -cursor - box2.height });
+    cursor += size(box2) + gap;
+  }
+  return positions;
+}
+function alignmentBox(shape) {
+  if (!shape.rotation || shape.kind !== "shape" || !(shape.width > 0 && shape.height > 0))
+    return void 0;
+  const [a, b, c, d, e, f] = shape.transform;
+  if (![a, b, c, d, e, f, shape.rotation.pinX, shape.rotation.pinY, shape.width, shape.height].every(
+    Number.isFinite
+  ))
+    return void 0;
+  const points = [
+    [0, 0],
+    [shape.width, 0],
+    [0, shape.height],
+    [shape.width, shape.height]
+  ];
+  const xs = points.map(([x2, y]) => a * x2 + c * y + e);
+  const ys = points.map(([x2, y]) => b * x2 + d * y + f);
+  const x = Math.min(...xs), top = Math.max(...ys);
+  const width = Math.max(...xs) - x, height = top - Math.min(...ys);
+  if (![x, top, width, height].every(Number.isFinite) || width <= 0 || height <= 0)
+    return void 0;
+  return { id: shape.id, x, y: -top, width, height };
+}
+function visioArrangeCommands(page, shapeIds, action) {
+  const minimum = action.type === "align" ? 2 : 3;
+  if (shapeIds.length < minimum || shapeIds.length > 1e3 || new Set(shapeIds).size !== shapeIds.length)
+    return void 0;
+  if (action.type === "align" ? !["left", "center", "right", "top", "middle", "bottom"].includes(action.edge) : action.type !== "distribute" || !["horizontal", "vertical"].includes(action.axis))
+    return void 0;
+  const shapes = [];
+  const boxes = [];
+  for (const id of shapeIds) {
+    const shape = visioStyleFormattingShape(page, id);
+    const box2 = shape && alignmentBox(shape);
+    if (!shape || !box2 || page.connectors.some(
+      (connection) => connection.fromShapeId === id || connection.toShapeId === id
+    ))
+      return void 0;
+    shapes.push(shape);
+    boxes.push(box2);
+  }
+  const reference = boxes[0];
+  const normalized = boxes.map((box2) => ({
+    ...box2,
+    x: box2.x - reference.x,
+    y: box2.y - reference.y
+  }));
+  const edge = action.type === "align" ? action.edge === "center" ? "centerH" : action.edge : void 0;
+  const positions = action.type === "align" ? alignElements(normalized, edge, {
+    reference: "slide",
+    slideSize: { width: reference.width, height: reference.height }
+  }) : distributeBoxes(normalized, action.axis);
+  const commands = [];
+  try {
+    for (let index = 0; index < shapes.length; index++) {
+      const shape = shapes[index], box2 = normalized[index];
+      const position = positions.get(shape.id);
+      if (!position) return void 0;
+      const dx = (position.x ?? box2.x) - box2.x, dy = -((position.y ?? box2.y) - box2.y);
+      if (Math.abs(dx) < 1e-10 && Math.abs(dy) < 1e-10) continue;
+      commands.push(
+        visioPageEditToDrawing(page, {
+          type: "move-shape",
+          pageId: page.id,
+          shapeId: shape.id,
+          x: shape.rotation.pinX + dx,
+          y: shape.rotation.pinY + dy
+        })
+      );
+    }
+  } catch {
+    return void 0;
+  }
+  return commands;
+}
+
+// visio/ui/selection.ts
+var EMPTY_SELECTION = Object.freeze([]);
+var selectionKey = (shape, pageId) => JSON.stringify([shape.pageId ?? pageId, shape.id]);
+function visioSelectionIsOnPage(selection, pageId) {
+  return !!selection && (selection.pageId === void 0 || selection.pageId === pageId);
+}
+function sameSelection(left, right) {
+  return left.length === right.length && left.every((shape, index) => {
+    const other = right[index];
+    return shape.id === other.id && shape.pageId === other.pageId && shape.name === other.name;
+  });
+}
+function snapshotSelection(model, pageIndex, input, visible) {
+  if (!Array.isArray(input)) throw new Error("Selection requires an array.");
+  const length = input.length;
+  if (length > VISIO_VISIBILITY_LIMITS.maxShapes)
+    throw new Error("Selection exceeds the supported shape count.");
+  const page = model?.pages[pageIndex];
+  const candidates = /* @__PURE__ */ new Map();
+  for (let index = 0; index < length; index++) {
+    const item = input[index];
+    const id = item?.id, name = item?.name, pageId = item?.pageId;
+    if (typeof id !== "string" || typeof name !== "string" || id.length > 1024 || name.length > 4096 || pageId !== void 0 && (typeof pageId !== "string" || pageId.length > 256))
+      throw new Error("Selection requires shape IDs, names and optional page IDs.");
+    const copied = Object.freeze({ id, name, ...pageId === void 0 ? {} : { pageId } });
+    const key = selectionKey(copied, page?.id ?? "");
+    if (!candidates.has(key)) candidates.set(key, copied);
+  }
+  if (!model || !page || !length) return EMPTY_SELECTION;
+  const accepted = /* @__PURE__ */ new Map();
+  const content = /* @__PURE__ */ new WeakMap();
+  for (const source of getVisioPageLayers(model, page.id)) {
+    const pending = source.shapes.map((shape) => ({ shape, ancestors: [] }));
+    while (pending.length) {
+      const { shape, ancestors } = pending.pop();
+      const key = selectionKey({ id: shape.id, pageId: source.id }, page.id);
+      if (candidates.has(key) && hasVisibleShapeContent(shape, visible, content))
+        accepted.set(key, ancestors);
+      for (const child of shape.children)
+        pending.push({ shape: child, ancestors: [...ancestors, key] });
+    }
+  }
+  const result = [];
+  for (const [key, item] of candidates) {
+    const ancestors = accepted.get(key);
+    if (!ancestors || ancestors.some((ancestor) => accepted.has(ancestor))) continue;
+    result.push(item);
+  }
+  return result.length ? Object.freeze(result) : EMPTY_SELECTION;
+}
+function hasVisibleShapeContent(shape, visible, cache = /* @__PURE__ */ new WeakMap()) {
+  const cached = cache.get(shape);
+  if (cached !== void 0) return cached;
+  const own = !(shape.kind === "group" && shape.groupDisplayMode === 0) && (shape.geometry.length > 0 || !!shape.image || !!shape.foreignVector || !!shape.text.plainText || shape.kind === "foreign");
+  const renderable = (visible?.get(shape) ?? !shape.hidden) && (own || shape.children.some((child) => hasVisibleShapeContent(child, visible, cache)));
+  cache.set(shape, renderable);
+  return renderable;
+}
+
+// visio/ui/shape-clipboard.ts
+function visioClipboardShape(page, shapeId) {
+  const shape = visioStyleFormattingShape(page, shapeId);
+  if (!shape || shape.kind !== "shape" || !(shape.width > 0) || !(shape.height > 0) || page.connectors.some(
+    (connection) => connection.fromShapeId === shapeId || connection.toShapeId === shapeId
+  ))
+    return void 0;
+  return shape;
+}
+function visioPasteCommand(page, value, offset = { x: 0.33, y: -0.33 }) {
+  try {
+    const clipboard = snapshotVisioClipboard(value);
+    if ((page.drawingToPageScale ?? 1) !== clipboard.sourceDrawingScale || [offset.x, offset.y].some((number) => !Number.isFinite(number) || Math.abs(number) > 1e6))
+      return void 0;
+    let next = Number(visioNextShapeId(page));
+    if (next + clipboard.shapes.length - 1 > 4294967295) return void 0;
+    const ids = new Map(clipboard.shapes.map((shape) => [shape.shapeId, String(next++)]));
+    return {
+      type: "paste-shapes",
+      pageId: page.id,
+      clipboard,
+      copies: clipboard.selectionIds.map((shapeId) => ({ shapeId, newShapeId: ids.get(shapeId) })),
+      offsetX: offset.x,
+      offsetY: offset.y
+    };
+  } catch {
+    return void 0;
+  }
+}
+
+// visio/ui/shape-move.ts
+function visioMovementShape(page, id) {
+  const shape = visioStyleFormattingShape(page, id);
+  if (!shape || shape.kind !== "shape" || !shape.rotation || !(shape.width > 0 && shape.height > 0) || ![
+    shape.width,
+    shape.height,
+    shape.rotation.pinX,
+    shape.rotation.pinY,
+    ...shape.transform
+  ].every(Number.isFinite) || page.connectors.some(
+    (connection) => connection.fromShapeId === id || connection.toShapeId === id
+  ))
+    return void 0;
+  return shape;
+}
+function visioPageDragDelta(start, end) {
+  return { x: end.x - start.x, y: start.y - end.y };
+}
+function visioMovePreviewTransform(shape, delta) {
+  if (![delta.x, delta.y, ...shape.transform].every(Number.isFinite)) return void 0;
+  const [a, b, c, d, e, f] = shape.transform;
+  const result = [a, b, c, d, e + delta.x, f + delta.y];
+  return result.every(Number.isFinite) ? result : void 0;
+}
+function visioMoveCommands(page, ids, delta) {
+  if (!ids.length || ids.length > 1e3 || new Set(ids).size !== ids.length || ![delta.x, delta.y].every(Number.isFinite))
+    return void 0;
+  const shapes = ids.map((id) => visioMovementShape(page, id));
+  if (shapes.some((shape) => !shape)) return void 0;
+  if (delta.x === 0 && delta.y === 0) return [];
+  try {
+    const edits = shapes.map(
+      (shape) => visioPageEditToDrawing(page, {
+        type: "move-shape",
+        pageId: page.id,
+        shapeId: shape.id,
+        x: shape.rotation.pinX + delta.x,
+        y: shape.rotation.pinY + delta.y
+      })
+    );
+    return edits.every(
+      (edit) => edit.type === "move-shape" && Number.isFinite(edit.x) && Number.isFinite(edit.y)
+    ) ? edits : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// visio/ui/size-position.ts
+var bounded = (value) => Number.isFinite(value) && Math.abs(value) <= 1e6;
+function visioSizePositionState(page, id) {
+  const shape = visioMovementShape(page, id), ratio = page.drawingToPageScale ?? 1;
+  if (!shape || !Number.isFinite(ratio) || ratio <= 0) return void 0;
+  const rotation = shape.rotation;
+  const state = {
+    pageId: page.id,
+    shapeId: id,
+    x: rotation.pinX / ratio,
+    y: rotation.pinY / ratio,
+    width: shape.width / ratio,
+    height: shape.height / ratio,
+    angle: rotation.angle * 180 / Math.PI
+  };
+  if (![state.x, state.y, state.width, state.height, rotation.angle].every(bounded) || !Number.isFinite(state.angle))
+    return void 0;
+  return Object.freeze(state);
+}
+function visioSizePositionCommand(page, id, field, value) {
+  const state = visioSizePositionState(page, id);
+  if (!state || !Number.isFinite(value)) return void 0;
+  if (!["x", "y", "width", "height", "angle"].includes(field)) return void 0;
+  if (value === state[field]) return [];
+  const target = { pageId: page.id, shapeId: id };
+  if (field === "angle") {
+    const angle = value * Math.PI / 180;
+    return bounded(angle) ? [{ type: "rotate-shape", ...target, angle }] : void 0;
+  }
+  if (!bounded(value)) return void 0;
+  if (field === "x" || field === "y")
+    return [
+      {
+        type: "move-shape",
+        ...target,
+        x: field === "x" ? value : state.x,
+        y: field === "y" ? value : state.y
+      }
+    ];
+  if (value <= 0) return void 0;
+  return [
+    {
+      type: "resize-shape",
+      ...target,
+      width: field === "width" ? value : state.width,
+      height: field === "height" ? value : state.height
+    }
+  ];
+}
+
+// visio/ui/marquee.ts
+function visioMarqueeBox(start, end) {
+  if (![start.x, start.y, end.x, end.y].every(Number.isFinite)) return void 0;
+  const box2 = {
+    x: Math.min(start.x, end.x),
+    y: Math.min(start.y, end.y),
+    width: Math.abs(end.x - start.x),
+    height: Math.abs(end.y - start.y)
+  };
+  return Object.values(box2).every(Number.isFinite) ? box2 : void 0;
+}
+function visioShapePageBox(page, shape) {
+  if (![page.height, shape.width, shape.height, ...shape.transform].every(Number.isFinite) || shape.width < 0 || shape.height < 0)
+    return void 0;
+  const [a, b, c, d, e, f] = shape.transform;
+  const corners = [
+    [0, 0],
+    [shape.width, 0],
+    [0, shape.height],
+    [shape.width, shape.height]
+  ];
+  const xs = corners.map(([x, y]) => a * x + c * y + e), ys = corners.map(([x, y]) => b * x + d * y + f);
+  const left = Math.min(...xs), right = Math.max(...xs), bottom = Math.min(...ys), top = Math.max(...ys);
+  const box2 = { x: left, y: page.height - top, width: right - left, height: top - bottom };
+  return Object.values(box2).every(Number.isFinite) ? box2 : void 0;
+}
+function visioMarqueeSelection(page, box2, visible) {
+  if (![box2.x, box2.y, box2.width, box2.height].every(Number.isFinite) || box2.width <= 0 || box2.height <= 0)
+    return [];
+  const cache = /* @__PURE__ */ new WeakMap();
+  return page.shapes.flatMap((shape) => {
+    const extent = visioShapePageBox(page, shape);
+    return extent && hasVisibleShapeContent(shape, visible, cache) && extent.x >= box2.x && extent.y >= box2.y && extent.x + extent.width <= box2.x + box2.width && extent.y + extent.height <= box2.y + box2.height ? [{ id: shape.id, name: shape.name, pageId: page.id }] : [];
+  });
+}
+
+// visio/ui/shape-resize.ts
+var VISIO_RESIZE_HANDLES = [
+  { id: "sw", x: 0, y: 0 },
+  { id: "s", x: 0.5, y: 0 },
+  { id: "se", x: 1, y: 0 },
+  { id: "e", x: 1, y: 0.5 },
+  { id: "ne", x: 1, y: 1 },
+  { id: "n", x: 0.5, y: 1 },
+  { id: "nw", x: 0, y: 1 },
+  { id: "w", x: 0, y: 0.5 }
+];
+function visioResizeShape(page, id) {
+  const shape = visioMovementShape(page, id);
+  return shape && visioResizeFrame(shape, { width: shape.width, height: shape.height }, { x: 0, y: 0 }) ? shape : void 0;
+}
+function visioResizeFrame(shape, size, anchor) {
+  if (!shape.rotation) return void 0;
+  const geometry = visioAnchoredResizeGeometry(
+    { ...shape, pinX: shape.rotation.pinX, pinY: shape.rotation.pinY },
+    size,
+    anchor
+  );
+  return geometry ? {
+    width: size.width,
+    height: size.height,
+    transform: geometry.transform,
+    pinX: geometry.pinX,
+    pinY: geometry.pinY
+  } : void 0;
+}
+function visioResizeDrag(page, id, handle, start, end) {
+  const shape = visioResizeShape(page, id), location = VISIO_RESIZE_HANDLES.find((item) => item.id === handle);
+  if (!shape || !location) return void 0;
+  const delta = visioPageDragDelta(start, end), [a, b, c, d] = shape.transform, determinant = a * d - b * c;
+  const x = (d * delta.x - c * delta.y) / determinant, y = (-b * delta.x + a * delta.y) / determinant;
+  const size = {
+    width: location.x === 0.5 ? shape.width : Math.max(Math.min(1 / 16, shape.width), shape.width + (location.x === 1 ? x : -x)),
+    height: location.y === 0.5 ? shape.height : Math.max(Math.min(1 / 16, shape.height), shape.height + (location.y === 1 ? y : -y))
+  };
+  const anchor = {
+    x: 1 - location.x,
+    y: 1 - location.y
+  };
+  const frame = visioResizeFrame(shape, size, anchor);
+  if (!frame) return void 0;
+  try {
+    const command = visioPageEditToDrawing(page, {
+      type: "resize-shape",
+      pageId: page.id,
+      shapeId: id,
+      ...size,
+      anchor
+    });
+    return command.type === "resize-shape" && command.width <= 1e6 && command.height <= 1e6 ? { frame, command } : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// visio/ui/draw-plan.ts
+var SNAP = 1 / 16;
+var boundedNumber = (value) => Number.isFinite(value) && Math.abs(value) <= 1e6;
+function visioDrawingPoint(page, point, options = {}) {
+  if (![point.x, point.y, page.width, page.height].every(boundedNumber) || page.width <= 0 || page.height <= 0)
+    return void 0;
+  const coordinate = (value, maximum) => {
+    const bounded2 = options.bounded === false ? value : Math.max(0, Math.min(maximum, value));
+    return options.snap === false ? bounded2 : Math.round(bounded2 / SNAP) * SNAP;
+  };
+  return { x: coordinate(point.x, page.width), y: coordinate(point.y, page.height) };
+}
+function visioDrawBounds(start, end) {
+  if (![start.x, start.y, end.x, end.y].every(boundedNumber))
+    throw new Error("Invalid drawing bounds.");
+  return {
+    x: Math.min(start.x, end.x),
+    y: Math.min(start.y, end.y),
+    width: Math.abs(end.x - start.x),
+    height: Math.abs(end.y - start.y),
+    centerX: (start.x + end.x) / 2,
+    centerY: (start.y + end.y) / 2,
+    radiusX: Math.abs(end.x - start.x) / 2,
+    radiusY: Math.abs(end.y - start.y) / 2
+  };
+}
+function visioBoxCreationCommand(page, kind, centre, size, text) {
+  if (!["rectangle", "ellipse", "text"].includes(kind) || ![centre.x, centre.y, size.width, size.height].every(boundedNumber) || size.width <= 0 || size.height <= 0)
+    throw new Error("Invalid box creation geometry or tool.");
+  const box2 = {
+    pageId: page.id,
+    shapeId: visioNextShapeId(page),
+    x: centre.x,
+    y: page.height - centre.y,
+    width: size.width,
+    height: size.height
+  };
+  const command = kind === "text" ? { ...box2, type: "create-text-box", text: text ?? "" } : {
+    ...box2,
+    type: kind === "ellipse" ? "create-ellipse" : "create-rectangle",
+    ...text === void 0 ? {} : { text }
+  };
+  return drawingCommand(page, command);
+}
+function drawingCommand(page, command) {
+  const result = visioPageEditToDrawing(page, command);
+  if (Object.values(result).some((value) => typeof value === "number" && !boundedNumber(value)))
+    throw new Error("Drawing coordinates exceed finite limits.");
+  return result;
+}
+function visioLineCreationCommand(page, begin, end) {
+  if (![begin.x, begin.y, end.x, end.y].every(boundedNumber))
+    throw new Error("Invalid line creation geometry.");
+  return drawingCommand(page, {
+    type: "create-line",
+    pageId: page.id,
+    shapeId: visioNextShapeId(page),
+    beginX: begin.x,
+    beginY: page.height - begin.y,
+    endX: end.x,
+    endY: page.height - end.y
+  });
+}
+function visioDrawIsLargeEnough(kind, start, end) {
+  if (!["rectangle", "ellipse", "line", "text"].includes(kind) || ![start.x, start.y, end.x, end.y].every(boundedNumber))
+    return false;
+  const bounds = visioDrawBounds(start, end);
+  return kind === "line" ? Math.hypot(bounds.width, bounds.height) >= SNAP : bounds.width >= SNAP && bounds.height >= SNAP;
+}
+function visioDrawPlan(page, kind, start, end, text) {
+  if (!visioDrawIsLargeEnough(kind, start, end)) return void 0;
+  const bounds = visioDrawBounds(start, end);
+  return kind === "line" ? visioLineCreationCommand(page, start, end) : visioBoxCreationCommand(page, kind, { x: bounds.centerX, y: bounds.centerY }, bounds, text);
+}
+
+// visio/ui/line-dash.ts
+function visioLineDashLengths(style) {
+  return style.lineDash?.map(
+    (length, index) => length === 0 && index % 2 === 0 ? style.lineDashDotLength ?? 0 : length * style.lineWidth
+  );
+}
+
+// visio/ui/shape-formatting.ts
+function visioShapeFormattingState(shapes) {
+  const common = (values) => values.length && values.every((value) => value === values[0]) ? values[0] : void 0;
+  const percent = (opacity) => opacity === void 0 || !Number.isFinite(opacity) || opacity < 0 || opacity > 1 ? void 0 : Math.round((1 - opacity) * 200) / 2;
+  const foreground = shapes.map(
+    (shape) => percent(
+      shape.style.fillForegroundOpacity ?? (shape.style.fillGradient || shape.style.fillPattern ? void 0 : shape.style.fillOpacity)
+    )
+  );
+  const background = shapes.map((shape) => percent(shape.style.fillBackgroundOpacity));
+  return {
+    linePattern: common(shapes.map((shape) => shape.style.linePattern)),
+    fillPatternIndex: common(shapes.map((shape) => shape.style.fillPatternIndex)),
+    fillBackgroundColor: common(shapes.map((shape) => shape.style.fillBackgroundColor)),
+    fillForegroundTransparency: common(foreground),
+    fillBackgroundTransparency: common(background),
+    fillTransparency: common([...foreground, ...background]),
+    lineTransparency: common(
+      shapes.map(
+        (shape) => percent(
+          shape.style.lineColorOpacity ?? (shape.style.lineGradient ? void 0 : shape.style.lineOpacity)
+        )
+      )
+    )
+  };
+}
+
+// visio/ui/text-replace-types.ts
+var VISIO_TEXT_REPLACE_LIMITS = Object.freeze({
+  query: 256,
+  replacement: 32768,
+  text: 2e6,
+  names: 1e6,
+  output: 1e6,
+  matches: 1e4,
+  commands: 1e3,
+  shapes: 25e3,
+  pages: 256,
+  depth: 64
+});
+var textReplaceError = (message) => {
+  throw new Error(message);
+};
+function replaceString(value, maximum, label) {
+  if (typeof value !== "string" || value.length > maximum)
+    return textReplaceError(`Replace ${label} exceeds supported string limits.`);
+  return value;
+}
+function replaceIdentity(value) {
+  const id = replaceString(value, 256, "identity");
+  if (!id) textReplaceError("Replace requires nonempty identities.");
+  return id;
+}
+
+// visio/ui/text-replace-snapshot.ts
+function snapshotReplaceScope(input) {
+  const query = replaceString(input.query, VISIO_TEXT_REPLACE_LIMITS.query, "query");
+  const scope = input.scope, pageId = replaceIdentity(input.pageId), matchCase = input.matchCase;
+  if (!query || matchCase !== true || !["selection", "current-page", "all-pages"].includes(scope))
+    textReplaceError(
+      "Replace requires a nonempty literal query, Match case, and an explicit scope."
+    );
+  let selection;
+  const original = input.selection;
+  if (original !== void 0) {
+    const length = original.length;
+    if (!Array.isArray(original) || !Number.isSafeInteger(length) || length > VISIO_TEXT_REPLACE_LIMITS.shapes || length < 0)
+      textReplaceError("Replace selection exceeds supported limits.");
+    selection = [];
+    for (let index = 0; index < length; index++) {
+      const item = original[index], id = replaceIdentity(item.id), page = item.pageId;
+      selection.push(
+        Object.freeze({ id, ...page === void 0 ? {} : { pageId: replaceIdentity(page) } })
+      );
+    }
+    Object.freeze(selection);
+  }
+  return Object.freeze({ query, scope, pageId, matchCase, ...selection ? { selection } : {} });
+}
+function replaceEntries(model, scope, requirePage = true) {
+  const pages = model.pages;
+  const count = pages.length;
+  if (!Array.isArray(pages) || !Number.isSafeInteger(count) || count > VISIO_TEXT_REPLACE_LIMITS.pages || count < 0)
+    textReplaceError("Replace page list exceeds supported limits.");
+  const all = [], identities = /* @__PURE__ */ new Map(), pageIds = /* @__PURE__ */ new Set(), seen = /* @__PURE__ */ new Set();
+  let characters = 0, names = 0;
+  for (let pageIndex = 0; pageIndex < count; pageIndex++) {
+    const page = pages[pageIndex], pageId = replaceIdentity(page.id), ids = /* @__PURE__ */ new Set();
+    if (pageIds.has(pageId)) textReplaceError("Replace page identities are ambiguous.");
+    pageIds.add(pageId);
+    const walk = (source, depth) => {
+      const length = source.length;
+      if (!Array.isArray(source) || !Number.isSafeInteger(length) || length < 0 || length > 0 && depth > VISIO_TEXT_REPLACE_LIMITS.depth || length > VISIO_TEXT_REPLACE_LIMITS.shapes)
+        textReplaceError("Replace shape list exceeds supported limits.");
+      for (let index = 0; index < length; index++) {
+        const shape = source[index], shapeId = replaceIdentity(shape.id);
+        if (seen.has(shape) || ids.has(shapeId) || seen.size >= VISIO_TEXT_REPLACE_LIMITS.shapes)
+          textReplaceError("Replace shape identities, depth or cycles are invalid.");
+        seen.add(shape);
+        ids.add(shapeId);
+        const text = replaceString(shape.text.plainText, VISIO_TEXT_REPLACE_LIMITS.text, "source text");
+        const name = replaceString(shape.name, 4096, "shape name");
+        names += name.length;
+        if (names > VISIO_TEXT_REPLACE_LIMITS.names) textReplaceError("Replace shape names exceed aggregate limits.");
+        characters += text.length;
+        if (characters > VISIO_TEXT_REPLACE_LIMITS.text) textReplaceError("Replace text exceeds aggregate limits.");
+        const entry = { pageId, shapeId, name, pageIndex, text, end: 0 };
+        identities.set(JSON.stringify([pageId, shapeId]), all.length);
+        all.push(entry);
+        walk(shape.children, depth + 1);
+        entry.end = all.length;
+      }
+    };
+    walk(page.shapes, 0);
+  }
+  if (requirePage && !pageIds.has(scope.pageId))
+    textReplaceError("Replace current page does not exist.");
+  if (scope.scope === "all-pages") return all;
+  if (scope.scope === "current-page") return all.filter((entry) => entry.pageId === scope.pageId);
+  const result = [], added = /* @__PURE__ */ new Set();
+  for (const selected of scope.selection ?? []) {
+    const pageId = selected.pageId ?? scope.pageId;
+    const start = identities.get(JSON.stringify([pageId, selected.id]));
+    if (start === void 0) return textReplaceError("Replace selected shape does not exist.");
+    for (let index = start; index < all[start].end; index++) {
+      const entry = all[index];
+      if (added.has(entry)) {
+        index = entry.end - 1;
+        continue;
+      }
+      result.push(entry);
+      added.add(entry);
+    }
+  }
+  return result;
+}
+
+// visio/ui/text-replace-selection.ts
+function visioTextOccurrenceSelection(model, occurrence) {
+  const pageId = replaceIdentity(occurrence.pageId), shapeId = replaceIdentity(occurrence.shapeId), start = occurrence.start, end = occurrence.end;
+  if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || end <= start)
+    return void 0;
+  const entries = replaceEntries(
+    model,
+    { pageId, scope: "all-pages"},
+    false
+  );
+  const entry = entries.find((item) => item.pageId === pageId && item.shapeId === shapeId);
+  if (!entry || end > entry.text.length) return void 0;
+  return Object.freeze({
+    pageIndex: entry.pageIndex,
+    selection: Object.freeze({ id: shapeId, name: entry.name, pageId })
+  });
+}
+
+// visio/ui/text-replace.ts
+function occurrences(entries, query) {
+  const result = [];
+  for (const entry of entries) {
+    let start = entry.text.indexOf(query);
+    while (start >= 0) {
+      if (result.length >= VISIO_TEXT_REPLACE_LIMITS.matches)
+        textReplaceError("Replace occurrence count exceeds limits.");
+      result.push(
+        Object.freeze({
+          pageId: entry.pageId,
+          shapeId: entry.shapeId,
+          start,
+          end: start + query.length
+        })
+      );
+      start = entry.text.indexOf(query, start + query.length);
+    }
+  }
+  return Object.freeze(result);
+}
+function visioTextReplaceOccurrences(model, input) {
+  const scope = snapshotReplaceScope(input);
+  return occurrences(replaceEntries(model, scope), scope.query);
+}
+function visioTextReplaceFindNext(model, input, current) {
+  const saved = snapshotOccurrence(current);
+  const found = visioTextReplaceOccurrences(model, input);
+  if (saved === void 0) return found[0];
+  const index = found.findIndex((match) => sameOccurrence(match, saved));
+  if (index < 0) return textReplaceError("Find occurrence is stale or outside the scope.");
+  return found[(index + 1) % found.length];
+}
+var records = /* @__PURE__ */ new WeakMap();
+var sameOccurrence = (a, b) => a.pageId === b.pageId && a.shapeId === b.shapeId && a.start === b.start && a.end === b.end;
+var sameTarget = (entry, match) => entry.pageId === match.pageId && entry.shapeId === match.shapeId;
+function snapshotOccurrence(original) {
+  if (original === void 0) return void 0;
+  const current = {
+    pageId: replaceIdentity(original.pageId),
+    shapeId: replaceIdentity(original.shapeId),
+    start: original.start,
+    end: original.end
+  };
+  if (!Number.isSafeInteger(current.start) || !Number.isSafeInteger(current.end) || current.start < 0 || current.end <= current.start || current.end > VISIO_TEXT_REPLACE_LIMITS.text)
+    textReplaceError("Invalid replacement occurrence range.");
+  return current;
+}
+function visioTextReplacePlan(model, input) {
+  const scope = snapshotReplaceScope(input), replacement = replaceString(input.replacement, VISIO_TEXT_REPLACE_LIMITS.replacement, "replacement"), mode = input.mode, current = snapshotOccurrence(input.current);
+  if (mode !== "current" && mode !== "all") textReplaceError("Invalid replacement mode.");
+  if (/[\u0000-\u0008\u000b\u000c\u000d\u000e-\u001f\ufffe\uffff]|[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/u.test(
+    replacement
+  ))
+    textReplaceError("Replacement contains invalid XML text characters.");
+  const entries = replaceEntries(model, scope), found = occurrences(entries, scope.query);
+  const active = current === void 0 ? found[0] : found.find((match) => sameOccurrence(match, current));
+  if (current !== void 0 && !active)
+    textReplaceError("Replace occurrence is stale or outside the scope.");
+  const selected = mode === "all" ? found : active ? [active] : [];
+  const targets = /* @__PURE__ */ new Map();
+  for (const match of selected) {
+    const key = JSON.stringify([match.pageId, match.shapeId]);
+    const list = targets.get(key) ?? [];
+    list.push(match);
+    targets.set(key, list);
+  }
+  if (targets.size > VISIO_TEXT_REPLACE_LIMITS.commands) textReplaceError("Replace command count exceeds limits.");
+  const edits = [], updated = [];
+  let outputCharacters = 0;
+  for (const entry of entries) {
+    const matches = targets.get(JSON.stringify([entry.pageId, entry.shapeId]));
+    let text = entry.text;
+    if (matches) {
+      const length = text.length + matches.length * (replacement.length - scope.query.length);
+      outputCharacters += length;
+      if (length > VISIO_TEXT_REPLACE_LIMITS.output || outputCharacters > VISIO_TEXT_REPLACE_LIMITS.output)
+        textReplaceError("Replace output exceeds aggregate command text limits.");
+      const parts = [];
+      let from = 0;
+      for (const match of matches) {
+        parts.push(text.slice(from, match.start), replacement);
+        from = match.end;
+      }
+      parts.push(text.slice(from));
+      text = parts.join("");
+      edits.push(
+        Object.freeze({
+          type: "replace-plain-text",
+          pageId: entry.pageId,
+          shapeId: entry.shapeId,
+          text
+        })
+      );
+    }
+    updated.push({ ...entry, text });
+  }
+  const remaining = mode === "current" ? occurrences(updated, scope.query) : [];
+  const activeEntry = active ? entries.findIndex((entry) => sameTarget(entry, active)) : -1;
+  const entryIndices = new Map(
+    entries.map((entry, index) => [JSON.stringify([entry.pageId, entry.shapeId]), index])
+  );
+  const nextOccurrence = active ? remaining.find((match) => {
+    const index = entryIndices.get(JSON.stringify([match.pageId, match.shapeId]));
+    return index > activeEntry || index === activeEntry && match.start >= active.start + replacement.length;
+  }) ?? remaining[0] : remaining[0];
+  const plan = Object.freeze({
+    occurrences: found,
+    replacementCount: selected.length,
+    edits: Object.freeze(edits),
+    nextOccurrence
+  });
+  records.set(plan, { scope, entries });
+  return plan;
+}
+function visioTextReplaceCommands(model, plan) {
+  const record2 = records.get(plan);
+  if (!record2) return textReplaceError("Replace plan was not produced by this planner.");
+  const current = replaceEntries(model, record2.scope);
+  if (current.length !== record2.entries.length || current.some((entry, index) => {
+    const saved = record2.entries[index];
+    return entry.pageId !== saved.pageId || entry.shapeId !== saved.shapeId || entry.text !== saved.text;
+  }))
+    textReplaceError("Replace plan is stale. Search the current drawing again.");
+  return plan.edits.map((edit) => ({ ...edit }));
+}
+
+// visio/ui/svg-stroke.ts
+function visioSvgStrokeStyle(style) {
+  return style.lineWidth === 0 ? { ...style, lineWidth: 0.75 / 72 } : style;
+}
+
+export { DocumentHistory, EDIT_HISTORY_LIMITS, EMPTY_EDIT_STATE, EMPTY_SELECTION, EMPTY_TEXT_SEARCH, FOREIGN_VECTOR_SCENE_LIMITS, ForeignVectorBudget, MAX_INPUT_BYTES, TEXT_SEARCH_LIMITS, IDENTITY_AFFINE as VISIO_IDENTITY_TRANSFORM, VISIO_RESIZE_HANDLES, VISIO_TEXT_REPLACE_LIMITS, assertShapeDetails, assertViewableDocument, compatibilityNotes, compatibilityText, composeAffine as composeVisioTransform, copySnapshotScene, demoDocument, editErrorMessage, eventKeys, hasVisibleShapeContent, indexDocumentText, inspectForeignVectorResource, isEditCancellation, propertyKeys, sameSelection, searchDocumentText, selectionKey, snapshotEdits, snapshotSelection, textSearchStatus, validateSearchQuery, visioArrangeCommands, visioBoxCreationCommand, visioClipboardShape, visioDrawBounds, visioDrawIsLargeEnough, visioDrawPlan, visioDrawingPoint, visioDuplicateCommand, visioFillPatternTransform, visioFontFamilies, visioFormattingShape, visioGradientInstances, visioLineCreationCommand, visioLineDashLengths, visioLocalRotationShape, visioMarqueeBox, visioMarqueeSelection, visioMoveCommands, visioMovePreviewTransform, visioMovementShape, visioNextShapeId, visioOrderingShape, visioPageDragDelta, visioPageEditToDrawing, visioPageInsertCommand, visioPasteCommand, visioQuarterTurnCommand, visioRenderedGradientStopCount, visioRenderedGradientStops, visioResizeDrag, visioResizeFrame, visioResizeShape, visioRotationPreviewTransform, visioSelectionIsOnPage, visioShapeFormattingState, visioShapePageBox, visioSizePositionCommand, visioSizePositionState, visioStraightLineHandles, visioStrokeGradient, visioStyleFormattingShape, visioSvgStrokeStyle, visioTextFontStepCommand, visioTextFormattingState, visioTextIndentCommand, visioTextOccurrenceSelection, visioTextReplaceCommands, visioTextReplaceFindNext, visioTextReplaceOccurrences, visioTextReplacePlan };