ooxml-core 1.2.1 → 1.4.0

package/dist/visio/ui/index.cjs

@@ -13,7 +13,8 @@ var eventKeys = [
   "document-error",
   "page-change",
   "zoom-change",
-  "shape-select"
+  "shape-select",
+  "selection-change"
 ];
 
 // visio/ui/demo-document.ts
@@ -324,6 +325,298 @@ 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/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/ui/edit-commands.ts
 function snapshotEdits(edits) {
   if (!Array.isArray(edits) || edits.length > 1e3)
@@ -332,12 +625,26 @@ 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.");
       return { type: command.type, pageId: command.pageId, index: command.index };
     }
     if (command.type === "delete-page") return { type: command.type, pageId: command.pageId };
+    if (command.type === "set-page-size") {
+      if (![command.width, command.height].every(
+        (value) => typeof value === "number" && Number.isFinite(value) && value > 0 && value <= 1e6
+      ))
+        throw new Error("Invalid physical page dimensions.");
+      return {
+        type: command.type,
+        pageId: command.pageId,
+        width: command.width,
+        height: command.height
+      };
+    }
     const text = (value) => {
       if (typeof value !== "string") throw new Error("Invalid edit text.");
       characters += value.length;
@@ -364,7 +671,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 {
@@ -377,6 +700,8 @@ function snapshotEdits(edits) {
         };
       case "replace-plain-text":
         return { type: command.type, ...target, text: text(command.text) };
+      case "replace-text-ranges":
+        return snapshotTextRanges(command, text);
       case "delete-shape":
         return { type: command.type, ...target };
       case "rotate-shape":
@@ -400,9 +725,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);
@@ -430,15 +763,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({
@@ -1378,6 +1702,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,
@@ -1575,6 +1922,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);
@@ -1601,6 +1953,9 @@ function assertViewableDocument(model) {
     finite2(page.height, "page height", 1e-3);
     if (page.drawingToPageScale !== void 0)
       finite2(page.drawingToPageScale, "drawing scale", Number.MIN_VALUE, Number.MAX_VALUE);
+    for (const mode of [page.drawingSizeType, page.drawingResizeType])
+      if (mode !== void 0 && (!Number.isSafeInteger(mode) || mode < 0 || mode > 255))
+        throw new Error("The scene has an invalid drawing page-size mode.");
     if (!Array.isArray(page.shapes) || stack.length + page.shapes.length > MAX_SHAPES)
       throw new Error("The scene exceeds safe shape count limits or has an invalid shape list.");
     const ids = /* @__PURE__ */ new Set();
@@ -1620,7 +1975,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);
@@ -1659,7 +2016,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.");
     }
@@ -1674,6 +2031,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);
@@ -1696,6 +2068,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);
@@ -1868,10 +2242,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",
@@ -1950,6 +2330,10 @@ function copySnapshotScene(model) {
   const text = (source) => ({
     ...fields(source, [
       "plainText",
+      "bold",
+      "italic",
+      "underline",
+      "strikethrough",
       "backgroundColor",
       "backgroundOpacity",
       "opacity",
@@ -1967,7 +2351,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) }
   });
@@ -1999,6 +2384,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",
@@ -2013,7 +2404,9 @@ function copySnapshotScene(model) {
         "height",
         "isBackground",
         "backgroundPageId",
-        "drawingToPageScale"
+        "drawingToPageScale",
+        "drawingSizeType",
+        "drawingResizeType"
       ]),
       shapes: shapes(page.shapes),
       connectors: []
@@ -2053,6 +2446,7 @@ function visioPageEditToDrawing(page, edit) {
       return edit;
     case "create-rectangle":
     case "create-ellipse":
+    case "create-text-box":
       return {
         ...edit,
         x: coordinate(edit.x),
@@ -2100,6 +2494,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];
@@ -2159,15 +2650,891 @@ function visioQuarterTurnCommand(page, shapeId, direction) {
   };
 }
 
+// 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, commandCharacters = 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("");
+      const target = { pageId: entry.pageId, shapeId: entry.shapeId };
+      if (replacement.includes("\n") || scope.query.includes("\n")) {
+        commandCharacters += text.length;
+        edits.push(Object.freeze({ type: "replace-plain-text", ...target, text }));
+      } else {
+        commandCharacters += entry.text.length + matches.length * replacement.length;
+        edits.push(
+          Object.freeze({
+            type: "replace-text-ranges",
+            ...target,
+            expectedText: entry.text,
+            ranges: Object.freeze(
+              matches.map(
+                (match) => Object.freeze({ start: match.start, end: match.end, text: replacement })
+              )
+            )
+          })
+        );
+      }
+      if (commandCharacters > VISIO_TEXT_REPLACE_LIMITS.output)
+        textReplaceError("Replace input exceeds aggregate command text limits.");
+    }
+    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.type === "replace-text-ranges" ? { ...edit, ranges: edit.ranges.map((range) => ({ ...range })) } : { ...edit }
+  );
+}
+
+// visio/ui/svg-stroke.ts
+function visioSvgStrokeStyle(style) {
+  return style.lineWidth === 0 ? { ...style, lineWidth: 0.75 / 72 } : style;
+}
+
+// visio/ui/page-size.ts
+var VISIO_PAGE_SIZE_PRESETS = Object.freeze([
+  Object.freeze({ id: "letter", label: "Letter", width: 8.5, height: 11 }),
+  Object.freeze({ id: "a4", label: "A4", width: 210 / 25.4, height: 297 / 25.4 })
+]);
+var dimension = (value) => Number.isFinite(value) && value > 0 && value <= 1e6;
+function visioPageSizeState(page) {
+  const { id: pageId, width, height, drawingSizeType, drawingResizeType } = page;
+  if (!dimension(width) || !dimension(height) || !pageId || pageId.length > 256) return void 0;
+  return Object.freeze({
+    pageId,
+    width,
+    height,
+    orientation: width === height ? "square" : width > height ? "landscape" : "portrait",
+    ...drawingSizeType === void 0 ? {} : { drawingSizeType },
+    ...drawingResizeType === void 0 ? {} : { drawingResizeType }
+  });
+}
+function visioPageSizeCommand(page, width, height) {
+  const state = visioPageSizeState(page);
+  if (!state || !dimension(width) || !dimension(height)) return void 0;
+  if (width === state.width && height === state.height && state.drawingSizeType === 3 && state.drawingResizeType === 0)
+    return [];
+  return [{ type: "set-page-size", pageId: state.pageId, width, height }];
+}
+function visioPageOrientationCommand(page, orientation) {
+  const state = visioPageSizeState(page);
+  if (!state || !["portrait", "landscape"].includes(orientation)) return void 0;
+  const short = Math.min(state.width, state.height), long = Math.max(state.width, state.height);
+  return visioPageSizeCommand(
+    page,
+    orientation === "portrait" ? short : long,
+    orientation === "portrait" ? long : short
+  );
+}
+function visioPageSizePresetCommand(page, id) {
+  const state = visioPageSizeState(page), preset = VISIO_PAGE_SIZE_PRESETS.find((item) => item.id === id);
+  if (!state || !preset) return void 0;
+  return visioPageSizeCommand(
+    page,
+    state.orientation === "landscape" ? preset.height : preset.width,
+    state.orientation === "landscape" ? preset.width : preset.height
+  );
+}
+
 exports.DocumentHistory = DocumentHistory;
 exports.EDIT_HISTORY_LIMITS = EDIT_HISTORY_LIMITS;
 exports.EMPTY_EDIT_STATE = EMPTY_EDIT_STATE;
+exports.EMPTY_SELECTION = EMPTY_SELECTION;
 exports.EMPTY_TEXT_SEARCH = EMPTY_TEXT_SEARCH;
 exports.FOREIGN_VECTOR_SCENE_LIMITS = FOREIGN_VECTOR_SCENE_LIMITS;
 exports.ForeignVectorBudget = ForeignVectorBudget;
 exports.MAX_INPUT_BYTES = MAX_INPUT_BYTES;
 exports.TEXT_SEARCH_LIMITS = TEXT_SEARCH_LIMITS;
 exports.VISIO_IDENTITY_TRANSFORM = IDENTITY_AFFINE;
+exports.VISIO_PAGE_SIZE_PRESETS = VISIO_PAGE_SIZE_PRESETS;
+exports.VISIO_RESIZE_HANDLES = VISIO_RESIZE_HANDLES;
+exports.VISIO_TEXT_REPLACE_LIMITS = VISIO_TEXT_REPLACE_LIMITS;
 exports.assertShapeDetails = assertShapeDetails;
 exports.assertViewableDocument = assertViewableDocument;
 exports.compatibilityNotes = compatibilityNotes;
@@ -2177,23 +3544,69 @@ exports.copySnapshotScene = copySnapshotScene;
 exports.demoDocument = demoDocument;
 exports.editErrorMessage = editErrorMessage;
 exports.eventKeys = eventKeys;
+exports.hasVisibleShapeContent = hasVisibleShapeContent;
 exports.indexDocumentText = indexDocumentText;
 exports.inspectForeignVectorResource = inspectForeignVectorResource;
 exports.isEditCancellation = isEditCancellation;
 exports.propertyKeys = propertyKeys;
+exports.sameSelection = sameSelection;
 exports.searchDocumentText = searchDocumentText;
+exports.selectionKey = selectionKey;
 exports.snapshotEdits = snapshotEdits;
+exports.snapshotSelection = snapshotSelection;
 exports.textSearchStatus = textSearchStatus;
 exports.validateSearchQuery = validateSearchQuery;
+exports.visioArrangeCommands = visioArrangeCommands;
+exports.visioBoxCreationCommand = visioBoxCreationCommand;
+exports.visioClipboardShape = visioClipboardShape;
+exports.visioDrawBounds = visioDrawBounds;
+exports.visioDrawIsLargeEnough = visioDrawIsLargeEnough;
+exports.visioDrawPlan = visioDrawPlan;
+exports.visioDrawingPoint = visioDrawingPoint;
+exports.visioDuplicateCommand = visioDuplicateCommand;
 exports.visioFillPatternTransform = visioFillPatternTransform;
+exports.visioFontFamilies = visioFontFamilies;
+exports.visioFormattingShape = visioFormattingShape;
 exports.visioGradientInstances = visioGradientInstances;
+exports.visioLineCreationCommand = visioLineCreationCommand;
+exports.visioLineDashLengths = visioLineDashLengths;
 exports.visioLocalRotationShape = visioLocalRotationShape;
+exports.visioMarqueeBox = visioMarqueeBox;
+exports.visioMarqueeSelection = visioMarqueeSelection;
+exports.visioMoveCommands = visioMoveCommands;
+exports.visioMovePreviewTransform = visioMovePreviewTransform;
+exports.visioMovementShape = visioMovementShape;
 exports.visioNextShapeId = visioNextShapeId;
+exports.visioOrderingShape = visioOrderingShape;
+exports.visioPageDragDelta = visioPageDragDelta;
 exports.visioPageEditToDrawing = visioPageEditToDrawing;
 exports.visioPageInsertCommand = visioPageInsertCommand;
+exports.visioPageOrientationCommand = visioPageOrientationCommand;
+exports.visioPageSizeCommand = visioPageSizeCommand;
+exports.visioPageSizePresetCommand = visioPageSizePresetCommand;
+exports.visioPageSizeState = visioPageSizeState;
+exports.visioPasteCommand = visioPasteCommand;
 exports.visioQuarterTurnCommand = visioQuarterTurnCommand;
 exports.visioRenderedGradientStopCount = visioRenderedGradientStopCount;
 exports.visioRenderedGradientStops = visioRenderedGradientStops;
+exports.visioResizeDrag = visioResizeDrag;
+exports.visioResizeFrame = visioResizeFrame;
+exports.visioResizeShape = visioResizeShape;
 exports.visioRotationPreviewTransform = visioRotationPreviewTransform;
+exports.visioSelectionIsOnPage = visioSelectionIsOnPage;
+exports.visioShapeFormattingState = visioShapeFormattingState;
+exports.visioShapePageBox = visioShapePageBox;
+exports.visioSizePositionCommand = visioSizePositionCommand;
+exports.visioSizePositionState = visioSizePositionState;
 exports.visioStraightLineHandles = visioStraightLineHandles;
 exports.visioStrokeGradient = visioStrokeGradient;
+exports.visioStyleFormattingShape = visioStyleFormattingShape;
+exports.visioSvgStrokeStyle = visioSvgStrokeStyle;
+exports.visioTextFontStepCommand = visioTextFontStepCommand;
+exports.visioTextFormattingState = visioTextFormattingState;
+exports.visioTextIndentCommand = visioTextIndentCommand;
+exports.visioTextOccurrenceSelection = visioTextOccurrenceSelection;
+exports.visioTextReplaceCommands = visioTextReplaceCommands;
+exports.visioTextReplaceFindNext = visioTextReplaceFindNext;
+exports.visioTextReplaceOccurrences = visioTextReplaceOccurrences;
+exports.visioTextReplacePlan = visioTextReplacePlan;