ooxml-core 0.19.0 → 0.21.0

package/dist/visio/ui/index.mjs

@@ -0,0 +1,1498 @@
+// src/visio/ui/contract.ts
+var propertyKeys = [
+  "document",
+  "pageIndex",
+  "zoom",
+  "showToolbar"
+];
+var eventKeys = [
+  "document-load",
+  "document-change",
+  "document-error",
+  "page-change",
+  "zoom-change",
+  "shape-select"
+];
+
+// src/visio/ui/demo-document.ts
+function box(id, name, x, y, width, height, fill, kind = "box") {
+  const path = kind === "diamond" ? `M ${width / 2} 0 L ${width} ${height / 2} L ${width / 2} ${height} L 0 ${height / 2} Z` : `M 0 0 L ${width} 0 L ${width} ${height} L 0 ${height} Z`;
+  return {
+    id,
+    name,
+    kind: "shape",
+    width,
+    height,
+    transform: [1, 0, 0, 1, x, y],
+    hidden: false,
+    children: [],
+    geometry: [{ path, fill: true, stroke: true }],
+    style: {
+      fill,
+      lineColor: "#326765",
+      lineWidth: 0.015,
+      linePattern: 1,
+      fillOpacity: 1,
+      lineOpacity: 1,
+      startArrow: 0,
+      endArrow: 0
+    },
+    text: {
+      plainText: name,
+      runs: [],
+      fontFamily: "Arial",
+      fontSize: 0.15,
+      color: "#203d40",
+      horizontalAlign: "center",
+      verticalAlign: "middle",
+      transform: [1, 0, 0, 1, 0, 0],
+      width,
+      height,
+      margins: { left: 0.06, right: 0.06, top: 0.06, bottom: 0.06 }
+    }
+  };
+}
+function line(id, x, y, path) {
+  const shape = box(id, "", x, y, 0, 0, "none");
+  shape.kind = "connector";
+  shape.geometry = [{ path, fill: false, stroke: true }];
+  return shape;
+}
+var demoDocument = {
+  format: "vsdx",
+  diagnostics: [],
+  pages: [
+    {
+      id: "1",
+      name: "Release workflow",
+      width: 8.5,
+      height: 7,
+      isBackground: false,
+      connectors: [],
+      shapes: [
+        box("s1", "Start with an idea", 2.8, 5.5, 2.8, 0.7, "#d8efeb"),
+        line("c1", 4.2, 5.5, "M 0 0 L 0 -.5"),
+        box("s2", "Design and build", 2.8, 4.3, 2.8, 0.7, "#f3eee1"),
+        line("c2", 4.2, 4.3, "M 0 0 L 0 -.45"),
+        box("s3", "Ready?", 3.35, 2.8, 1.7, 1.05, "#dfebf7", "diamond"),
+        line("c3", 4.2, 2.8, "M 0 0 L 0 -.5"),
+        box("s4", "Review and release", 2.8, 1.6, 2.8, 0.7, "#d8efeb"),
+        line("c4", 5.05, 3.325, "M 0 0 L 1.3 0 L 1.3 1.325 L .55 1.325"),
+        box(
+          "note",
+          "Explore pages \xB7 Select shapes\nZoom with + / \u2212 \xB7 Fit with 0",
+          2.3,
+          0.45,
+          3.8,
+          0.7,
+          "#ffffff"
+        )
+      ]
+    },
+    {
+      id: "2",
+      name: "Architecture",
+      width: 8.5,
+      height: 5.5,
+      isBackground: false,
+      connectors: [],
+      shapes: [
+        box("a1", "Your framework", 0.7, 3.5, 2, 0.9, "#dfebf7"),
+        box("a2", "One viewer", 3.2, 3.5, 2, 0.9, "#d8efeb"),
+        box("a3", "ooxml-core", 5.7, 3.5, 2, 0.9, "#f3eee1"),
+        line("ac1", 2.7, 3.95, "M 0 0 L .5 0"),
+        line("ac2", 5.2, 3.95, "M 0 0 L .5 0"),
+        box(
+          "a4",
+          "Framework-neutral rendering\nLocal files. Explicit compatibility notes.",
+          1.55,
+          1.5,
+          5.4,
+          1,
+          "#ffffff"
+        )
+      ]
+    }
+  ]
+};
+
+// src/visio/ui/diagnostics.ts
+function compatibilityNotes(diagnostics, renderWarnings = []) {
+  const notes = /* @__PURE__ */ new Map();
+  for (const diagnostic of diagnostics) {
+    const existing = notes.get(diagnostic.message);
+    if (existing) {
+      existing.count++;
+      if (diagnostic.severity === "warning") existing.severity = "warning";
+    } else
+      notes.set(diagnostic.message, {
+        message: diagnostic.message,
+        count: 1,
+        severity: diagnostic.severity
+      });
+  }
+  for (const message of renderWarnings) {
+    const existing = notes.get(message);
+    if (existing) {
+      existing.count++;
+      existing.severity = "warning";
+    } else notes.set(message, { message, count: 1, severity: "warning" });
+  }
+  return [...notes.values()].sort(
+    (a, b) => Number(a.severity === "info") - Number(b.severity === "info")
+  );
+}
+function compatibilityText(note) {
+  return note.message + (note.count > 1 ? ` (${note.count} occurrences)` : "");
+}
+
+// src/visio/ui/document-history.ts
+var EMPTY_EDIT_STATE = Object.freeze({
+  sourceAvailable: false,
+  busy: false,
+  dirty: false,
+  canUndo: false,
+  canRedo: false,
+  historyTruncated: false,
+  error: null,
+  diagnostics: Object.freeze([])
+});
+var EDIT_HISTORY_LIMITS = Object.freeze({ maxBytes: 96 * 1024 * 1024, maxEntries: 20 });
+var DocumentHistory = class {
+  original;
+  #entries;
+  #index = 0;
+  #truncated = false;
+  constructor(bytes) {
+    this.original = { bytes: Uint8Array.from(bytes), diagnostics: Object.freeze([]) };
+    this.#entries = [this.original];
+  }
+  get current() {
+    return this.#entries[this.#index];
+  }
+  get undoTarget() {
+    return this.#entries[this.#index - 1];
+  }
+  get redoTarget() {
+    return this.#entries[this.#index + 1];
+  }
+  get state() {
+    return Object.freeze({
+      ...EMPTY_EDIT_STATE,
+      sourceAvailable: true,
+      dirty: this.current !== this.original,
+      canUndo: !!this.undoTarget,
+      canRedo: !!this.redoTarget,
+      historyTruncated: this.#truncated,
+      diagnostics: this.current.diagnostics
+    });
+  }
+  append(bytes, diagnostics) {
+    const snapshot = {
+      bytes: Uint8Array.from(bytes),
+      diagnostics: Object.freeze(
+        diagnostics.map((note) => Object.freeze({ code: note.code, message: note.message }))
+      )
+    };
+    this.#entries = this.#entries.slice(0, this.#index + 1);
+    this.#entries.push(snapshot);
+    this.#index++;
+    const retained = () => /* @__PURE__ */ new Set([this.original, ...this.#entries]);
+    while (this.#entries.length > EDIT_HISTORY_LIMITS.maxEntries || [...retained()].reduce((sum, entry) => sum + entry.bytes.byteLength, 0) > EDIT_HISTORY_LIMITS.maxBytes) {
+      if (this.#index === 0) throw new Error("Source snapshots exceed the retained history limit.");
+      this.#entries.shift();
+      this.#index--;
+      this.#truncated = true;
+    }
+  }
+  move(target) {
+    const index = this.#entries.indexOf(target);
+    if (index < 0 || Math.abs(index - this.#index) !== 1)
+      throw new Error("The history target is stale.");
+    this.#index = index;
+  }
+  export() {
+    return {
+      bytes: Uint8Array.from(this.current.bytes),
+      dirty: this.current !== this.original,
+      diagnostics: this.current.diagnostics
+    };
+  }
+};
+
+// src/visio/ui/document-text-search.ts
+var TEXT_SEARCH_LIMITS = Object.freeze({
+  queryCharacters: 256,
+  results: 500,
+  indexedCharacters: 2e6,
+  shapeCharacters: 32768,
+  previewCharacters: 160,
+  shapes: 25e3,
+  depth: 64
+});
+var EMPTY_TEXT_SEARCH = Object.freeze({
+  query: "",
+  results: Object.freeze([]),
+  activeIndex: -1,
+  indexTruncated: false,
+  resultsTruncated: false
+});
+function indexDocumentText(model, isVisible = (shape) => !shape.hidden) {
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  let characters = 0, truncated = false;
+  for (const [pageIndex, page] of (model?.pages ?? []).entries()) {
+    const stack = page.shapes.map((shape) => ({ shape, depth: 0 })).reverse();
+    while (stack.length) {
+      const { shape, depth } = stack.pop();
+      if (seen.has(shape) || depth > TEXT_SEARCH_LIMITS.depth) {
+        truncated = true;
+        continue;
+      }
+      if (seen.size >= TEXT_SEARCH_LIMITS.shapes)
+        return Object.freeze({ entries: Object.freeze(entries), truncated: true });
+      seen.add(shape);
+      if (!isVisible(shape)) continue;
+      if (!(shape.kind === "group" && shape.groupDisplayMode === 0)) {
+        const source = shape.text.plainText;
+        const length = Math.min(
+          source.length,
+          TEXT_SEARCH_LIMITS.shapeCharacters,
+          TEXT_SEARCH_LIMITS.indexedCharacters - characters
+        );
+        if (length < source.length) truncated = true;
+        if (length) {
+          characters += length;
+          const text = source.slice(0, length);
+          const preview = text.slice(0, TEXT_SEARCH_LIMITS.previewCharacters) + (source.length > TEXT_SEARCH_LIMITS.previewCharacters ? "\u2026" : "");
+          entries.push(
+            Object.freeze({
+              foldedText: text.toLowerCase(),
+              result: Object.freeze({
+                pageIndex,
+                pageId: page.id,
+                pageName: page.name,
+                shapeId: shape.id,
+                shapeName: shape.name,
+                preview
+              })
+            })
+          );
+        }
+      }
+      for (let i = shape.children.length - 1; i >= 0; i--)
+        stack.push({ shape: shape.children[i], depth: depth + 1 });
+    }
+  }
+  return Object.freeze({ entries: Object.freeze(entries), truncated });
+}
+function validateSearchQuery(query) {
+  if (typeof query !== "string" || query.length > TEXT_SEARCH_LIMITS.queryCharacters)
+    throw new Error(
+      `Search queries must be strings of at most ${TEXT_SEARCH_LIMITS.queryCharacters} characters.`
+    );
+}
+function searchDocumentText(index, query) {
+  validateSearchQuery(query);
+  const results = [];
+  let resultsTruncated = false;
+  if (query.trim()) {
+    const folded = query.toLowerCase();
+    for (const entry of index.entries) {
+      if (!entry.foldedText.includes(folded)) continue;
+      if (results.length === TEXT_SEARCH_LIMITS.results) {
+        resultsTruncated = true;
+        break;
+      }
+      results.push(entry.result);
+    }
+  }
+  return Object.freeze({
+    query,
+    results: Object.freeze(results),
+    activeIndex: -1,
+    indexTruncated: index.truncated,
+    resultsTruncated
+  });
+}
+function textSearchStatus(search) {
+  if (!search.query.trim()) return "Find text across pages";
+  const count = search.results.length;
+  const result = search.activeIndex < 0 ? `${count}${search.resultsTruncated ? "+" : ""} matching shapes` : `${search.activeIndex + 1} of ${count}${search.resultsTruncated ? "+" : ""} matching shapes`;
+  return result + (search.indexTruncated ? " \xB7 Partial text index" : "");
+}
+
+// src/visio/ui/edit-commands.ts
+function snapshotEdits(edits) {
+  if (!Array.isArray(edits) || edits.length > 1e3)
+    throw new Error("At most 1000 edits are accepted per operation.");
+  let characters = 0;
+  return edits.map((command) => {
+    if (!command || typeof command.pageId !== "string" || !command.pageId || command.pageId.length > 256 || typeof command.shapeId !== "string" || !command.shapeId || command.shapeId.length > 256)
+      throw new Error("Invalid edit command.");
+    const target = { pageId: command.pageId, shapeId: command.shapeId };
+    const text = (value) => {
+      if (typeof value !== "string") throw new Error("Invalid edit text.");
+      characters += value.length;
+      if (characters > 1e6)
+        throw new Error("Edit text exceeds the one-million-character limit.");
+      return value;
+    };
+    const numbers = (...values) => {
+      if (values.some((value) => typeof value !== "number" || !Number.isFinite(value)))
+        throw new Error("Invalid geometry edit coordinates or dimensions.");
+    };
+    switch (command.type) {
+      case "replace-plain-text":
+        return { type: command.type, ...target, text: text(command.text) };
+      case "delete-shape":
+        return { type: command.type, ...target };
+      case "move-shape":
+        numbers(command.x, command.y);
+        return { type: command.type, ...target, x: command.x, y: command.y };
+      case "resize-shape":
+        numbers(command.width, command.height);
+        return { type: command.type, ...target, width: command.width, height: command.height };
+      case "create-rectangle":
+        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,
+          ...command.text === void 0 ? {} : { text: text(command.text) }
+        };
+      default:
+        throw new Error("Invalid edit command type.");
+    }
+  });
+}
+
+// src/visio/ui/edit-error.ts
+function editErrorMessage(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const code = error && typeof error === "object" && "code" in error && typeof error.code === "string" ? error.code.slice(0, 256) : void 0;
+  return code ? `${code}: ${message}` : message;
+}
+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;
+}
+
+// src/visio/foreign-vector-types.ts
+var VISIO_FOREIGN_VECTOR_LIMITS = Object.freeze({
+  maxNodes: 25e3,
+  maxCharacters: 2 * 1024 * 1024,
+  maxPathOperands: 1e5,
+  maxPathCommands: 5e4,
+  maxDepth: 64,
+  maxDimension: 2048,
+  maxCoordinate: 1e6,
+  maxExpandedNodes: 25e3,
+  maxExpandedOperands: 1e5,
+  maxExpandedCommands: 5e4
+});
+var VisioForeignVectorError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  code;
+  name = "VisioForeignVectorError";
+};
+function unsafe(message) {
+  throw new VisioForeignVectorError("unsafe-vector", message);
+}
+function limit(message) {
+  throw new VisioForeignVectorError("vector-limit", message);
+}
+
+// src/visio/foreign-vector-values.ts
+var IDENTITY = Object.freeze([1, 0, 0, 1, 0, 0]);
+var NUMBER = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/;
+function record(value, allowed) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    unsafe("Expected a plain object.");
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) unsafe("Unexpected object prototype.");
+  const result = /* @__PURE__ */ Object.create(null);
+  const keys = Reflect.ownKeys(value);
+  if (keys.length > allowed.length) unsafe("Unexpected object fields.");
+  for (const key of keys) {
+    if (typeof key !== "string" || !allowed.includes(key)) unsafe("Unexpected object field.");
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor || !("value" in descriptor) || !descriptor.enumerable)
+      unsafe("Invalid data property.");
+    result[key] = descriptor.value;
+  }
+  return result;
+}
+function limitsFor(options) {
+  const result = { ...VISIO_FOREIGN_VECTOR_LIMITS };
+  const values = record(options, Object.keys(result));
+  for (const key of Object.keys(values)) {
+    const value = values[key];
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1 || value > result[key])
+      unsafe("Limits must be positive integers no greater than the defaults.");
+    result[key] = value;
+  }
+  return result;
+}
+function finite(value, maximum) {
+  if (typeof value !== "number" || !Number.isFinite(value)) unsafe("Expected a finite number.");
+  if (Math.abs(value) > maximum) limit("Numeric magnitude limit exceeded.");
+  return value;
+}
+function scalar(value, maximum, minimum = 0) {
+  if (typeof value === "string") {
+    if (!NUMBER.test(value)) unsafe("Invalid numeric attribute.");
+    value = Number(value);
+  }
+  const n = finite(value, maximum);
+  if (n < minimum) unsafe("Numeric attribute below its minimum.");
+  return n;
+}
+function compose(a, b, max) {
+  const result = [
+    a[0] * b[0] + a[2] * b[1],
+    a[1] * b[0] + a[3] * b[1],
+    a[0] * b[2] + a[2] * b[3],
+    a[1] * b[2] + a[3] * b[3],
+    a[0] * b[4] + a[2] * b[5] + a[4],
+    a[1] * b[4] + a[3] * b[5] + a[5]
+  ];
+  for (const value of result) finite(value, max);
+  return result;
+}
+function rule(value) {
+  if (value === void 0) return "nonzero";
+  if (value !== "nonzero" && value !== "evenodd") unsafe("Unsupported winding rule.");
+  return value;
+}
+function literal(value, fallback) {
+  if (value === void 0) return fallback;
+  if (typeof value !== "string" || !/^(?:none|#[0-9a-fA-F]{6})$/.test(value))
+    unsafe("Nonliteral paint.");
+  return value.toLowerCase();
+}
+function choice(value, choices, fallback) {
+  if (value === void 0) return fallback;
+  if (typeof value !== "string" || !choices.includes(value))
+    unsafe("Unsupported paint value.");
+  return value;
+}
+function paint(attrs) {
+  return Object.freeze({
+    fill: literal(attrs.fill, "#000000"),
+    stroke: literal(attrs.stroke, "none"),
+    fillRule: rule(attrs["fill-rule"]),
+    strokeWidth: scalar(attrs["stroke-width"] === void 0 ? 1 : attrs["stroke-width"], 1024),
+    strokeMiterlimit: scalar(
+      attrs["stroke-miterlimit"] === void 0 ? 4 : attrs["stroke-miterlimit"],
+      1024,
+      1
+    ),
+    strokeLinecap: choice(attrs["stroke-linecap"], ["butt", "round", "square"], "butt"),
+    strokeLinejoin: choice(attrs["stroke-linejoin"], ["miter", "round", "bevel"], "miter"),
+    opacity: scalar(attrs.opacity === void 0 ? 1 : attrs.opacity, 1),
+    fillOpacity: scalar(attrs["fill-opacity"] === void 0 ? 1 : attrs["fill-opacity"], 1),
+    strokeOpacity: scalar(attrs["stroke-opacity"] === void 0 ? 1 : attrs["stroke-opacity"], 1)
+  });
+}
+
+// src/visio/foreign-vector-path.ts
+function checkPathBounds(commands, matrix2, max) {
+  const point = (x2, y2) => {
+    finite(x2, max);
+    finite(y2, max);
+    finite(matrix2[0] * x2 + matrix2[2] * y2 + matrix2[4], max);
+    finite(matrix2[1] * x2 + matrix2[3] * y2 + matrix2[5], max);
+  };
+  let x = 0, y = 0, startX = 0, startY = 0;
+  for (const { command, values: v } of commands) {
+    if (command === "Z") {
+      x = startX;
+      y = startY;
+      continue;
+    }
+    if (command === "A") {
+      const endX = v[5], endY = v[6];
+      point(endX, endY);
+      if (v[0] !== 0 && v[1] !== 0 && (x !== endX || y !== endY)) {
+        const angle = v[2] % 360 * Math.PI / 180, c = Math.cos(angle), s = Math.sin(angle);
+        const dx = (x - endX) / 2, dy = (y - endY) / 2;
+        const scale = Math.max(
+          1,
+          Math.hypot((c * dx + s * dy) / v[0], (-s * dx + c * dy) / v[1])
+        );
+        const rx = finite(v[0] * scale, max), ry = finite(v[1] * scale, max);
+        const bx = 2 * (Math.abs(c) * rx + Math.abs(s) * ry);
+        const by = 2 * (Math.abs(s) * rx + Math.abs(c) * ry);
+        for (const signX of [-1, 1])
+          for (const signY of [-1, 1]) point(x + signX * bx, y + signY * by);
+      }
+      x = endX;
+      y = endY;
+    } else {
+      for (let i = 0; i < v.length; i += 2) point(v[i], v[i + 1]);
+      x = v[v.length - 2];
+      y = v[v.length - 1];
+      if (command === "M") {
+        startX = x;
+        startY = y;
+      }
+    }
+  }
+}
+
+// src/visio/foreign-vector-graph.ts
+function checkVectorGraph(scene, limits) {
+  let characters = scene.kind.length;
+  function strings(target) {
+    if ("kind" in target) characters += target.kind.length;
+    if ("commands" in target) {
+      characters += target.commands.length;
+      if ("clipRule" in target) characters += target.clipRule.length;
+      if ("paint" in target) {
+        const p = target.paint;
+        characters += p.fill.length + p.stroke.length + p.fillRule.length + p.strokeLinecap.length + p.strokeLinejoin.length;
+      }
+    } else for (const child of target.items) strings(child);
+    if (characters > limits.maxCharacters) limit("Retained vector character limit exceeded.");
+  }
+  for (const clip of scene.clips) strings(clip);
+  for (const item of scene.items) strings(item);
+  const active = /* @__PURE__ */ new Set(), done = /* @__PURE__ */ new Set();
+  const depths = /* @__PURE__ */ new Map();
+  function checkClip(index, depth) {
+    if (depth > limits.maxDepth) limit("Clip graph depth limit exceeded.");
+    if (active.has(index)) unsafe("Cyclic clip reference.");
+    if (done.has(index)) return depths.get(index);
+    active.add(index);
+    const clip = scene.clips[index];
+    let height = 1;
+    for (const target of [clip, ...clip.items]) {
+      if (target.clipIndex !== void 0)
+        height = Math.max(height, 1 + checkClip(target.clipIndex, depth + 1));
+    }
+    if (height > limits.maxDepth) limit("Clip graph depth limit exceeded.");
+    active.delete(index);
+    done.add(index);
+    depths.set(index, height);
+    return height;
+  }
+  for (let i = 0; i < scene.clips.length; i++) checkClip(i, 1);
+  let expandedNodes = 0, expandedOperands = 0, expandedCommands = 0;
+  function charge(depth) {
+    if (depth > limits.maxDepth) limit("Expanded vector depth limit exceeded.");
+    if (++expandedNodes > limits.maxExpandedNodes) limit("Expanded vector node limit exceeded.");
+  }
+  function content(target, parent, depth) {
+    charge(depth);
+    const matrix2 = compose(parent, target.matrix, limits.maxCoordinate);
+    if ("commands" in target) {
+      expandedCommands += target.commands.length;
+      if (expandedCommands > limits.maxExpandedCommands)
+        limit("Expanded path command limit exceeded.");
+      for (const command of target.commands) expandedOperands += command.values.length;
+      if (expandedOperands > limits.maxExpandedOperands)
+        limit("Expanded path operand limit exceeded.");
+      checkPathBounds(target.commands, matrix2, limits.maxCoordinate);
+      if ("paint" in target && target.paint.stroke !== "none") {
+        const extent = target.paint.strokeWidth * target.paint.strokeMiterlimit;
+        finite(extent * (Math.abs(matrix2[0]) + Math.abs(matrix2[2])), limits.maxCoordinate);
+        finite(extent * (Math.abs(matrix2[1]) + Math.abs(matrix2[3])), limits.maxCoordinate);
+      }
+    } else for (const child of target.items) content(child, matrix2, depth + 1);
+    if (target.clipIndex !== void 0) content(scene.clips[target.clipIndex], matrix2, depth + 1);
+  }
+  for (const clip of scene.clips) content(clip, IDENTITY, 1);
+  for (const item of scene.items) content(item, IDENTITY, 1);
+}
+
+// src/visio/foreign-vector-validation.ts
+var ARITY = { M: 2, L: 2, C: 6, Q: 4, A: 7, Z: 0 };
+var PAINT = {
+  fill: "fill",
+  stroke: "stroke",
+  fillRule: "fill-rule",
+  strokeWidth: "stroke-width",
+  strokeMiterlimit: "stroke-miterlimit",
+  strokeLinecap: "stroke-linecap",
+  strokeLinejoin: "stroke-linejoin",
+  opacity: "opacity",
+  fillOpacity: "fill-opacity",
+  strokeOpacity: "stroke-opacity"
+};
+function validateVisioForeignVector(value, options = {}) {
+  try {
+    return validate(value, limitsFor(options));
+  } catch (error) {
+    if (error instanceof VisioForeignVectorError) throw error;
+    unsafe("Unable to inspect vector scene safely.");
+  }
+}
+function validate(value, limits) {
+  let nodes = 0, operands = 0, commands = 0, characters = 0, clipCount = 0;
+  const seen = /* @__PURE__ */ new WeakSet();
+  function own(input, fields2, depth) {
+    if (depth > limits.maxDepth) limit("Scene depth limit exceeded.");
+    if (++nodes > limits.maxNodes) limit("Scene node limit exceeded.");
+    if (!input || typeof input !== "object" || seen.has(input))
+      unsafe("Repeated or cyclic scene object.");
+    seen.add(input);
+    return data(input, fields2);
+  }
+  function data(input, fields2) {
+    const output = record(input, fields2);
+    for (const value2 of Object.values(output)) {
+      characters += typeof value2 === "string" ? value2.length : 0;
+      if (characters > limits.maxCharacters) limit("Scene character limit exceeded.");
+    }
+    return output;
+  }
+  function array(input, maximum) {
+    if (!Array.isArray(input) || Object.getPrototypeOf(input) !== Array.prototype)
+      unsafe("Expected plain scene array.");
+    if (input.length > maximum) limit("Scene array limit exceeded.");
+    if (Reflect.ownKeys(input).length !== input.length + 1)
+      unsafe("Sparse or extended scene array.");
+    const output = [];
+    for (let i = 0; i < input.length; i++) {
+      const item2 = Object.getOwnPropertyDescriptor(input, i);
+      if (!item2 || !("value" in item2) || !item2.enumerable)
+        unsafe("Sparse or accessor scene array.");
+      output.push(item2.value);
+    }
+    return output;
+  }
+  function base(input) {
+    const values = array(input.matrix, 6);
+    if (values.length !== 6) unsafe("Invalid matrix arity.");
+    const matrix2 = Object.freeze(
+      values.map((item2) => finite(item2, limits.maxCoordinate))
+    );
+    if (input.clipIndex === void 0) return { matrix: matrix2 };
+    if (typeof input.clipIndex !== "number" || !Number.isSafeInteger(input.clipIndex) || input.clipIndex < 0 || input.clipIndex >= clipCount)
+      unsafe("Invalid clip index.");
+    return { matrix: matrix2, clipIndex: input.clipIndex };
+  }
+  function path(input) {
+    const values = array(input, limits.maxPathCommands - commands);
+    const result = [];
+    for (const value2 of values) {
+      const command = data(value2, ["command", "values"]);
+      if (typeof command.command !== "string" || !Object.hasOwn(ARITY, command.command))
+        unsafe("Invalid normalized command.");
+      if (!result.length && command.command !== "M") unsafe("Path must begin with moveto.");
+      const count = ARITY[command.command];
+      const numbers = array(command.values, count);
+      if (numbers.length !== count) unsafe("Invalid normalized command arity.");
+      if ((operands += count) > limits.maxPathOperands) limit("Scene operand limit exceeded.");
+      commands++;
+      const copied = numbers.map((item2) => finite(item2, limits.maxCoordinate));
+      if (command.command === "A" && (copied[0] < 0 || copied[1] < 0 || ![0, 1].includes(copied[3]) || ![0, 1].includes(copied[4])))
+        unsafe("Invalid normalized arc.");
+      result.push(
+        Object.freeze({
+          command: command.command,
+          values: Object.freeze(copied)
+        })
+      );
+    }
+    return Object.freeze(result);
+  }
+  function literalPaint(input) {
+    const fields2 = Object.keys(PAINT);
+    const value2 = data(input, fields2);
+    if (Object.keys(value2).length !== fields2.length) unsafe("Missing normalized paint field.");
+    const attrs = /* @__PURE__ */ Object.create(null);
+    for (const field of fields2) {
+      if (value2[field] === void 0) unsafe("Missing normalized paint value.");
+      if (["strokeWidth", "strokeMiterlimit", "opacity", "fillOpacity", "strokeOpacity"].includes(
+        field
+      ) && typeof value2[field] !== "number")
+        unsafe("Normalized paint must be numeric.");
+      attrs[PAINT[field]] = value2[field];
+    }
+    return paint(attrs);
+  }
+  function item(input, depth) {
+    const node = own(input, ["kind", "matrix", "clipIndex", "items", "commands", "paint"], depth);
+    if (node.kind === "path") {
+      if (Object.hasOwn(node, "items")) unsafe("Path contains group fields.");
+      return Object.freeze({
+        kind: "path",
+        ...base(node),
+        commands: path(node.commands),
+        paint: literalPaint(node.paint)
+      });
+    }
+    if (node.kind !== "group" || Object.hasOwn(node, "commands") || Object.hasOwn(node, "paint"))
+      unsafe("Invalid normalized group.");
+    return Object.freeze({
+      kind: "group",
+      ...base(node),
+      items: Object.freeze(
+        array(node.items, limits.maxNodes - nodes).map((child) => item(child, depth + 1))
+      )
+    });
+  }
+  function clip(input, depth) {
+    const node = own(input, ["matrix", "clipIndex", "items"], depth);
+    const items2 = [];
+    for (const value2 of array(node.items, limits.maxNodes - nodes)) {
+      const child = own(value2, ["matrix", "clipIndex", "commands", "clipRule"], depth + 1);
+      if (child.clipRule !== "nonzero" && child.clipRule !== "evenodd")
+        unsafe("Invalid normalized clip rule.");
+      items2.push(
+        Object.freeze({ ...base(child), commands: path(child.commands), clipRule: child.clipRule })
+      );
+    }
+    return Object.freeze({ ...base(node), items: Object.freeze(items2) });
+  }
+  const root = own(value, ["kind", "width", "height", "items", "clips"], 0);
+  if (root.kind !== "vector") unsafe("Invalid normalized vector.");
+  const width = finite(root.width, limits.maxDimension), height = finite(root.height, limits.maxDimension);
+  if (width < 1 || height < 1) unsafe("Empty normalized dimensions.");
+  const definitions = array(root.clips, limits.maxNodes - nodes);
+  clipCount = definitions.length;
+  const clips = Object.freeze(definitions.map((value2) => clip(value2, 1)));
+  const items = Object.freeze(
+    array(root.items, limits.maxNodes - nodes).map((value2) => item(value2, 1))
+  );
+  const scene = { kind: "vector", width, height, clips, items };
+  checkVectorGraph(scene, limits);
+  return Object.freeze(scene);
+}
+
+// src/visio/media.ts
+var VISIO_RASTER_IMAGE_LIMITS = Object.freeze({
+  maxImageBytes: 8 * 1024 * 1024,
+  maxPixels: 16e6,
+  maxDimension: 16384
+});
+var VisioImageError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "VisioImageError";
+  }
+  code;
+};
+var invalid = (message) => {
+  throw new VisioImageError("invalid-image", message);
+};
+var unsupported = (message) => {
+  throw new VisioImageError("unsupported-image", message);
+};
+function dimensions(width, height, limits) {
+  if (!width || !height) invalid("Raster image has zero dimensions.");
+  if (width > limits.maxDimension || height > limits.maxDimension || width * height > limits.maxPixels)
+    throw new VisioImageError(
+      "image-limit",
+      "Raster image dimensions exceed the configured limit."
+    );
+}
+var ascii = (bytes, start, length) => String.fromCharCode(...bytes.subarray(start, start + length));
+function png(bytes, limits) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (bytes.length < 33 || view.getUint32(8) !== 13 || ascii(bytes, 12, 4) !== "IHDR")
+    return invalid("PNG is missing a complete IHDR header.");
+  const width = view.getUint32(16), height = view.getUint32(20);
+  dimensions(width, height, limits);
+  const depth = bytes[24], color = bytes[25];
+  const depths = {
+    0: [1, 2, 4, 8, 16],
+    2: [8, 16],
+    3: [1, 2, 4, 8],
+    4: [8, 16],
+    6: [8, 16]
+  };
+  if (!depths[color]?.includes(depth) || bytes[26] !== 0 || bytes[27] !== 0 || bytes[28] > 1)
+    invalid("PNG header uses invalid color, compression, filter, or interlace values.");
+  let data = false;
+  for (let at = 8; at < bytes.length; ) {
+    if (at + 12 > bytes.length) invalid("Truncated PNG chunk.");
+    const length = view.getUint32(at), type = ascii(bytes, at + 4, 4), end = at + length + 12;
+    if (end > bytes.length) invalid("Truncated PNG chunk payload.");
+    if ((crc32(bytes.subarray(at + 4, end - 4)) ^ 4294967295) >>> 0 !== view.getUint32(end - 4))
+      invalid("PNG chunk checksum mismatch.");
+    if (type === "acTL") unsupported("Animated PNG is not supported.");
+    if (type === "IHDR" && at !== 8) invalid("PNG contains multiple image headers.");
+    if (type === "IDAT" && length) data = true;
+    if (type === "IEND") {
+      if (length || end !== bytes.length || !data) invalid("PNG has an invalid image terminator.");
+      return [width, height];
+    }
+    at = end;
+  }
+  return invalid("PNG has no image terminator.");
+}
+function gif(bytes, limits) {
+  if (bytes.length < 13) return invalid("GIF is missing a complete screen descriptor.");
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const width = view.getUint16(6, true), height = view.getUint16(8, true);
+  dimensions(width, height, limits);
+  let at = 13 + (bytes[10] & 128 ? 3 * 2 ** ((bytes[10] & 7) + 1) : 0);
+  let frames = 0, pixels = 0;
+  const blocks = () => {
+    for (; ; ) {
+      if (at >= bytes.length) invalid("GIF has truncated data blocks.");
+      const size = bytes[at++];
+      if (!size) return;
+      at += size;
+      if (at > bytes.length) invalid("GIF has a truncated data block.");
+    }
+  };
+  while (at < bytes.length) {
+    const marker = bytes[at++];
+    if (marker === 59) {
+      if (!frames || at !== bytes.length) invalid("GIF has an invalid image terminator.");
+      return [width, height];
+    }
+    if (marker === 33) {
+      if (at >= bytes.length) invalid("GIF has a truncated extension.");
+      at++;
+      blocks();
+      continue;
+    }
+    if (marker !== 44 || at + 9 > bytes.length) invalid("GIF has an invalid image descriptor.");
+    const left = view.getUint16(at, true), top = view.getUint16(at + 2, true);
+    const frameWidth = view.getUint16(at + 4, true), frameHeight = view.getUint16(at + 6, true);
+    dimensions(frameWidth, frameHeight, limits);
+    if (left + frameWidth > width || top + frameHeight > height)
+      invalid("GIF frame exceeds its screen.");
+    pixels += width * height;
+    if (pixels > limits.maxPixels)
+      throw new VisioImageError("image-limit", "GIF animation exceeds the pixel limit.");
+    const packed = bytes[at + 8];
+    at += 9 + (packed & 128 ? 3 * 2 ** ((packed & 7) + 1) : 0);
+    if (at >= bytes.length || bytes[at] < 2 || bytes[at] > 8)
+      invalid("GIF has an invalid LZW header.");
+    at++;
+    blocks();
+    frames++;
+  }
+  return invalid("GIF has no image terminator.");
+}
+function jpeg(bytes, limits) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let at = 2, width = 0, height = 0, scan = false;
+  while (at < bytes.length) {
+    if (bytes[at++] !== 255) invalid("JPEG has an invalid segment marker.");
+    while (bytes[at] === 255) at++;
+    const marker = bytes[at++];
+    if (marker === 217) {
+      if (!width || !scan || at !== bytes.length) invalid("JPEG has an invalid image terminator.");
+      return [width, height];
+    }
+    if (marker === void 0 || marker === 0 || marker === 216 || marker === 1 || marker >= 208 && marker <= 215)
+      invalid("JPEG has an unexpected standalone marker.");
+    if (at + 2 > bytes.length) invalid("JPEG has a truncated segment header.");
+    const length = view.getUint16(at), end = at + length;
+    if (length < 2 || end > bytes.length) invalid("JPEG has a truncated segment.");
+    if (marker >= 192 && marker <= 207 && ![196, 200, 204].includes(marker)) {
+      if (![192, 193, 194].includes(marker))
+        unsupported("This JPEG frame coding is unsupported.");
+      if (width || length < 11 || bytes[at + 2] !== 8 || length !== 8 + 3 * bytes[at + 7])
+        invalid("JPEG has an invalid frame header.");
+      height = view.getUint16(at + 3);
+      width = view.getUint16(at + 5);
+      dimensions(width, height, limits);
+    }
+    if (marker === 220) unsupported("JPEG deferred dimensions are unsupported.");
+    at = end;
+    if (marker === 218) {
+      if (!width || length < 8 || length !== 6 + 2 * bytes[end - length + 2])
+        invalid("JPEG has an invalid scan header.");
+      scan = true;
+      while (at < bytes.length) {
+        if (bytes[at] !== 255) {
+          at++;
+          continue;
+        }
+        const next = bytes[at + 1];
+        if (next === 0 || next !== void 0 && next >= 208 && next <= 215) {
+          at += 2;
+          continue;
+        }
+        break;
+      }
+    }
+  }
+  return invalid("JPEG has no image terminator.");
+}
+function inspectVisioRasterImage(bytes, options = {}) {
+  if (!options || typeof options !== "object" || Array.isArray(options))
+    throw new VisioImageError("invalid-limit", "Image limits must be an options object.");
+  const limits = { ...VISIO_RASTER_IMAGE_LIMITS, ...options };
+  for (const key of Object.keys(VISIO_RASTER_IMAGE_LIMITS)) {
+    const value = limits[key];
+    if (!Number.isSafeInteger(value) || value <= 0 || value > VISIO_RASTER_IMAGE_LIMITS[key])
+      throw new VisioImageError("invalid-limit", `Invalid raster image limit: ${key}.`);
+  }
+  if (!(bytes instanceof Uint8Array)) invalid("Raster image bytes must be a Uint8Array.");
+  if (bytes.byteLength > limits.maxImageBytes)
+    throw new VisioImageError("image-limit", "Raster image bytes exceed the configured limit.");
+  return inspect(bytes, limits);
+}
+function inspect(bytes, limits) {
+  let mimeType, size;
+  if ([137, 80, 78, 71, 13, 10, 26, 10].every((value, index) => bytes[index] === value)) {
+    mimeType = "image/png";
+    size = png(bytes, limits);
+  } else if (["GIF87a", "GIF89a"].includes(ascii(bytes, 0, 6))) {
+    mimeType = "image/gif";
+    size = gif(bytes, limits);
+  } else if (bytes[0] === 255 && bytes[1] === 216) {
+    mimeType = "image/jpeg";
+    size = jpeg(bytes, limits);
+  } else return unsupported("Foreign data is not a supported PNG, JPEG, or GIF raster image.");
+  return { mimeType, pixelWidth: size[0], pixelHeight: size[1] };
+}
+
+// src/visio/ui/foreign-vector-budget.ts
+var FOREIGN_VECTOR_SCENE_LIMITS = Object.freeze({
+  maxNodes: 1e5,
+  maxCommands: 4e5,
+  maxOperands: 1e6
+});
+function inspectForeignVectorResource(source) {
+  const vector = validateVisioForeignVector(source);
+  let nodes = 1, commands = 0, operands = 0, svgBytes = 1536;
+  const count = (item, retained) => {
+    nodes++;
+    if (retained) svgBytes += 1024;
+    if ("commands" in item) {
+      commands += item.commands.length;
+      if (retained) svgBytes += item.commands.length * 4;
+      for (const command of item.commands) {
+        operands += command.values.length;
+        if (retained) svgBytes += command.values.length * 32;
+      }
+    } else for (const child of item.items) count(child, retained);
+    if (item.clipIndex !== void 0) count(vector.clips[item.clipIndex], false);
+  };
+  for (const clip of vector.clips) count(clip, true);
+  for (const item of vector.items) count(item, true);
+  return {
+    vector,
+    nodes,
+    commands,
+    operands,
+    svgBytes,
+    validationWork: nodes * 128 + commands * 32 + operands * 8
+  };
+}
+var ForeignVectorBudget = class {
+  nodes = 0;
+  commands = 0;
+  operands = 0;
+  take(source) {
+    const resource = inspectForeignVectorResource(source);
+    this.nodes += resource.nodes;
+    this.commands += resource.commands;
+    this.operands += resource.operands;
+    if (this.nodes > FOREIGN_VECTOR_SCENE_LIMITS.maxNodes || this.commands > FOREIGN_VECTOR_SCENE_LIMITS.maxCommands || this.operands > FOREIGN_VECTOR_SCENE_LIMITS.maxOperands)
+      throw new Error("The scene exceeds aggregate foreign vector work limits.");
+    return resource;
+  }
+};
+
+// src/visio/ui/scene-details.ts
+function assertShapeDetails(shape, budget) {
+  const data = shape.shapeData ?? [], links = shape.hyperlinks ?? [];
+  if (!Array.isArray(data) || !Array.isArray(links) || data.length + links.length > 1024 || (budget.rows += data.length + links.length) > 1e5)
+    throw new Error("The scene exceeds shape metadata row limits.");
+  const strings = (record2, names, required = false) => {
+    for (const name of names)
+      if ((required || record2[name] !== void 0) && typeof record2[name] !== "string")
+        throw new Error("The scene has invalid shape metadata text.");
+  };
+  const booleans = (record2, names) => {
+    for (const name of names)
+      if (record2[name] !== void 0 && typeof record2[name] !== "boolean")
+        throw new Error("The scene has invalid shape metadata flags.");
+  };
+  const count = (record2, skipTarget = false) => {
+    const values = Object.entries(record2);
+    if (values.length > 32) throw new Error("The scene has excessive shape metadata fields.");
+    for (const [name, value] of values) {
+      if (skipTarget && name === "target") continue;
+      if (typeof value === "string") {
+        if (value.length > 8192 || (budget.characters += value.length) > 5e6)
+          throw new Error("The scene exceeds shape metadata string limits.");
+      } else if (typeof value === "number") {
+        if (!Number.isFinite(value)) throw new Error("The scene has invalid numeric metadata.");
+      } else if (value !== void 0 && value !== null && typeof value !== "boolean")
+        throw new Error("The scene has invalid shape metadata values.");
+    }
+  };
+  for (const row of data) {
+    const record2 = row;
+    strings(record2, ["id", "name", "valueKind"], true);
+    strings(record2, [
+      "label",
+      "rawType",
+      "rawValue",
+      "unit",
+      "error",
+      "format",
+      "prompt",
+      "sortKey"
+    ]);
+    booleans(record2, ["invisible"]);
+    count(row);
+  }
+  for (const row of links) {
+    const record2 = row;
+    strings(record2, ["id", "name"], true);
+    strings(record2, ["description", "address", "subAddress", "sortKey"]);
+    booleans(record2, ["default", "newWindow", "invisible"]);
+    count(row, true);
+    if (!row.target || typeof row.target !== "object" || Array.isArray(row.target))
+      throw new Error("The scene has invalid hyperlink metadata.");
+    const target = row.target;
+    const key = row.target.kind === "external" ? "href" : row.target.kind === "internal" ? "subAddress" : row.target.kind === "unresolved" ? "reason" : void 0;
+    if (!key) throw new Error("The scene has invalid hyperlink metadata.");
+    strings(target, [key], true);
+    count(row.target);
+  }
+}
+
+// src/visio/ui/scene-validation.ts
+var MAX_INPUT_BYTES = 32 * 1024 * 1024;
+var MAX_DIMENSION = 1e4;
+var MAX_SHAPES = 25e3;
+function finite2(value, label, min = -MAX_DIMENSION, max = MAX_DIMENSION) {
+  if (!Number.isFinite(value) || value < min || value > max)
+    throw new Error(`The scene has an invalid ${label}.`);
+}
+function member(value, choices, label) {
+  if (!choices.includes(value)) throw new Error(`The scene has an invalid ${label}.`);
+}
+function assertViewableDocument(model) {
+  if (model.format !== "vsdx" && model.format !== "vsd" || !Array.isArray(model.pages) || model.pages.length > 256 || !Array.isArray(model.diagnostics) || model.diagnostics.length > 2e3)
+    throw new Error("The scene has an invalid page list.");
+  const seen = /* @__PURE__ */ new Set();
+  let pathBytes = 0, textBytes = 0, runCount = 0, imageBytes = 0, geometryCount = 0, uniquePixels = 0, drawnPixels = 0, layerCount = 0, paragraphCount = 0, gradientStops = 0;
+  const imageResources = /* @__PURE__ */ new Map();
+  const vectorBudget = new ForeignVectorBudget();
+  let metadataBytes = 0;
+  const detailBudget = { rows: 0, characters: 0 };
+  const label = (value, limit2 = 4096) => {
+    if (typeof value !== "string" || value.length > limit2)
+      throw new Error("The scene exceeds safe metadata string limits.");
+    metadataBytes += value.length;
+    if (metadataBytes > 1e6) throw new Error("The scene exceeds aggregate metadata limits.");
+  };
+  for (const diagnostic of model.diagnostics) {
+    label(diagnostic.code, 256);
+    label(diagnostic.message);
+    member(diagnostic.severity, ["info", "warning"], "diagnostic severity");
+  }
+  const pageIds = /* @__PURE__ */ new Set();
+  const stack = [];
+  for (const page of model.pages) {
+    label(page.id, 256);
+    if (pageIds.has(page.id)) throw new Error("The scene has duplicate page identities.");
+    pageIds.add(page.id);
+    label(page.name);
+    if (page.layers !== void 0 && !Array.isArray(page.layers))
+      throw new Error("The scene has an invalid layer list.");
+    layerCount += page.layers?.length ?? 0;
+    if (layerCount > 25e3) throw new Error("The scene exceeds safe layer count limits.");
+    for (const layer of page.layers ?? []) {
+      label(layer.id, 256);
+      label(layer.name);
+      for (const flag of [layer.visible, layer.printable, layer.locked])
+        member(flag, [true, false], "layer flag");
+    }
+    finite2(page.width, "page width", 1e-3);
+    finite2(page.height, "page height", 1e-3);
+    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();
+    for (const shape of page.shapes) stack.push({ shape, depth: 0, ids });
+  }
+  while (stack.length) {
+    const { shape, depth, ids } = stack.pop();
+    if (depth > 64 || seen.has(shape) || seen.size >= MAX_SHAPES)
+      throw new Error("The scene exceeds safe shape depth/count limits or contains a cycle.");
+    seen.add(shape);
+    if (!Array.isArray(shape.children) || seen.size + stack.length + shape.children.length > MAX_SHAPES)
+      throw new Error("The scene exceeds safe shape count limits or has an invalid child list.");
+    label(shape.id, 1024);
+    if (ids.has(shape.id)) throw new Error("The scene has duplicate shape identities on one page.");
+    ids.add(shape.id);
+    member(shape.hidden, [true, false], "hidden flag");
+    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.verticalAlign, ["top", "middle", "bottom"], "text alignment");
+    label(shape.name);
+    label(shape.text.fontFamily, 1024);
+    label(shape.style.fill, 256);
+    label(shape.style.lineColor, 256);
+    label(shape.text.color, 256);
+    if (shape.text.backgroundColor) label(shape.text.backgroundColor, 256);
+    if (shape.text.backgroundOpacity !== void 0)
+      finite2(shape.text.backgroundOpacity, "text background opacity", 0, 1);
+    assertShapeDetails(shape, detailBudget);
+    if (shape.visibility) {
+      member(shape.visibility.layerHidden, [true, false], "layer visibility metadata");
+      member(shape.visibility.guide, [true, false], "guide visibility metadata");
+      member(shape.visibility.noShow, [void 0, true, false], "NoShow visibility metadata");
+      member(shape.visibility.nonPrinting, [void 0, true, false], "NonPrinting metadata");
+      member(
+        shape.visibility.layerPrintSummary,
+        ["unlayered", "all-enabled", "all-disabled", "mixed", "unknown"],
+        "layer print summary"
+      );
+    }
+    finite2(shape.width, "shape width", 0);
+    finite2(shape.height, "shape height", 0);
+    if (shape.transform.length !== 6 || shape.text.transform.length !== 6)
+      throw new Error("The scene has an invalid transform.");
+    for (const value of [...shape.transform, ...shape.text.transform]) finite2(value, "transform");
+    finite2(shape.text.width, "text width", 0);
+    finite2(shape.text.height, "text height", 0);
+    finite2(shape.text.fontSize, "font size", 0, 100);
+    finite2(shape.style.lineWidth, "line width", 0, 100);
+    if (shape.style.lineDash !== void 0) {
+      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);
+      if (!dash.some((value) => value > 0))
+        throw new Error("The scene has an empty line dash pattern.");
+    }
+    for (const value of [shape.style.linePattern, shape.style.startArrow, shape.style.endArrow]) {
+      finite2(value, "line pattern or arrow code", 0, 65535);
+      if (!Number.isInteger(value))
+        throw new Error("The scene has an invalid line pattern or arrow code.");
+    }
+    for (const size of [shape.style.startArrowSize, shape.style.endArrowSize])
+      if (size !== void 0) finite2(size, "arrow size", 0, 65535);
+    if (shape.style.lineCap !== void 0 && !["round", "butt", "square"].includes(shape.style.lineCap))
+      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.fillGradient) {
+      const gradient = shape.style.fillGradient;
+      if (gradient.type !== "linear" || !Array.isArray(gradient.stops) || gradient.stops.length < 2 || gradient.stops.length > 128 || gradient.start.length !== 2 || gradient.end.length !== 2)
+        throw new Error("The scene has an invalid fill gradient.");
+      if ((gradientStops += gradient.stops.length) > 1e5)
+        throw new Error("The scene exceeds aggregate gradient stop limits.");
+      for (const value of [...gradient.start, ...gradient.end])
+        finite2(value, "gradient position", -2e4, 2e4);
+      let offset = -1;
+      for (const stop of gradient.stops) {
+        finite2(stop.offset, "gradient stop", 0, 1);
+        finite2(stop.opacity, "gradient opacity", 0, 1);
+        label(stop.color, 256);
+        if (stop.offset < offset) throw new Error("Gradient stops must be ordered.");
+        offset = stop.offset;
+      }
+    }
+    if (typeof shape.text.plainText !== "string")
+      throw new Error("The scene has invalid plain text.");
+    textBytes += shape.text.plainText.length;
+    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) {
+      label(run.fontFamily, 1024);
+      label(run.color, 256);
+      if (typeof run.text !== "string") throw new Error("The scene has invalid run text.");
+      textBytes += run.text.length;
+      ++runCount;
+      finite2(run.fontSize, "run font size", 0, 100);
+    }
+    if (!Array.isArray(shape.geometry) || geometryCount + shape.geometry.length > 1e5)
+      throw new Error("The scene exceeds safe geometry limits or has an invalid geometry list.");
+    for (const geometry of shape.geometry) {
+      if (typeof geometry.path !== "string") throw new Error("The scene has invalid path text.");
+      member(geometry.fill, [true, false], "geometry fill flag");
+      member(geometry.stroke, [true, false], "geometry stroke flag");
+      pathBytes += geometry.path.length;
+      geometryCount++;
+    }
+    if (geometryCount > 1e5) throw new Error("The scene exceeds safe geometry limits.");
+    if (pathBytes > 16e6 || textBytes > 5e6 || runCount > 1e5)
+      throw new Error("The scene exceeds safe path/text limits.");
+    for (const value of [
+      shape.text.margins.left,
+      shape.text.margins.right,
+      shape.text.margins.top,
+      shape.text.margins.bottom
+    ])
+      finite2(value, "text margin");
+    const paragraphs = shape.text.paragraphs ?? [];
+    if (!Array.isArray(paragraphs) || paragraphs.length > 5e3 || (paragraphCount += paragraphs.length) > 5e4)
+      throw new Error("The scene exceeds safe paragraph limits.");
+    for (const paragraph of paragraphs) {
+      member(paragraph.direction, ["ltr", "rtl"], "paragraph direction");
+      member(
+        paragraph.horizontalAlign,
+        ["left", "center", "right", "justify", "distributed"],
+        "paragraph alignment"
+      );
+      member(paragraph.lineSpacing.kind, ["multiple", "exact"], "paragraph line spacing");
+      if (!Number.isSafeInteger(paragraph.start) || !Number.isSafeInteger(paragraph.end) || paragraph.start < 0 || paragraph.end < paragraph.start || paragraph.end > shape.text.plainText.length)
+        throw new Error("The scene has invalid paragraph offsets.");
+      for (const value of [
+        paragraph.indentLeft,
+        paragraph.indentRight,
+        paragraph.indentFirst,
+        paragraph.spaceBefore,
+        paragraph.spaceAfter
+      ])
+        finite2(value, "paragraph position");
+      finite2(paragraph.lineSpacing.value, "line spacing", 0, 100);
+      if (paragraph.bullet) {
+        label(paragraph.bullet.text, 1024);
+        label(paragraph.bullet.fontFamily, 1024);
+        finite2(paragraph.bullet.fontSize, "bullet size", 0, 100);
+        finite2(paragraph.bullet.offset, "bullet offset");
+      }
+    }
+    if (shape.foreignVector !== void 0) {
+      const foreign = shape.foreignVector;
+      if (!foreign || typeof foreign !== "object")
+        throw new Error("The scene has an invalid foreign vector placement.");
+      finite2(foreign.x, "foreign vector position");
+      finite2(foreign.y, "foreign vector position");
+      finite2(foreign.width, "foreign vector width", 0);
+      finite2(foreign.height, "foreign vector height", 0);
+      finite2(foreign.opacity, "foreign vector opacity", 0, 1);
+      vectorBudget.take(foreign.vector);
+    }
+    if (shape.image) {
+      const image = shape.image;
+      if (!["image/png", "image/jpeg", "image/gif"].includes(image.mimeType) || !(image.bytes instanceof Uint8Array))
+        throw new Error("Unsupported embedded image.");
+      imageBytes += image.bytes.byteLength;
+      if (image.bytes.byteLength > 8 * 1024 * 1024 || imageBytes > 64 * 1024 * 1024)
+        throw new Error("The scene exceeds safe image limits.");
+      finite2(image.pixelWidth, "image width", 1, 16384);
+      finite2(image.pixelHeight, "image height", 1, 16384);
+      drawnPixels += image.pixelWidth * image.pixelHeight;
+      if (!imageResources.has(image.bytes)) {
+        imageResources.set(image.bytes, image);
+        uniquePixels += image.pixelWidth * image.pixelHeight;
+      } else {
+        const previous = imageResources.get(image.bytes);
+        if (previous.mimeType !== image.mimeType || previous.pixelWidth !== image.pixelWidth || previous.pixelHeight !== image.pixelHeight)
+          throw new Error("Shared raster bytes have inconsistent declared metadata.");
+      }
+      if (uniquePixels > 64e6 || drawnPixels > 256e6)
+        throw new Error("The scene exceeds aggregate decoded image limits.");
+      if (image.opacity !== void 0) finite2(image.opacity, "image opacity", 0, 1);
+      if (image.pixelWidth * image.pixelHeight > VISIO_RASTER_IMAGE_LIMITS.maxPixels)
+        throw new Error("The scene exceeds safe image pixel limits.");
+      if (image.x !== void 0) finite2(image.x, "image position");
+      if (image.y !== void 0) finite2(image.y, "image position");
+      if (image.width !== void 0) finite2(image.width, "image width", 0);
+      if (image.height !== void 0) finite2(image.height, "image height", 0);
+    }
+    for (const child of shape.children) stack.push({ shape: child, depth: depth + 1, ids });
+  }
+  for (const image of imageResources.values()) {
+    const actual = inspectVisioRasterImage(image.bytes);
+    if (actual.mimeType !== image.mimeType || actual.pixelWidth !== image.pixelWidth || actual.pixelHeight !== image.pixelHeight)
+      throw new Error("Declared raster MIME or dimensions do not match the embedded bytes.");
+  }
+}
+
+// src/visio/ui/snapshot-scene.ts
+function fields(source, keys) {
+  const result = {};
+  for (const key of keys) {
+    const value = source[key];
+    if (value !== null && (typeof value === "object" || typeof value === "function"))
+      throw invalid2();
+    if (value !== void 0) result[key] = value;
+  }
+  return result;
+}
+var matrix = (value) => [
+  value[0],
+  value[1],
+  value[2],
+  value[3],
+  value[4],
+  value[5]
+];
+var invalid2 = () => new Error("The scene exceeds safe snapshot copy limits.");
+function copySnapshotScene(model) {
+  const counts = /* @__PURE__ */ new Map();
+  const take = (key, amount, maximum) => {
+    const total = (counts.get(key) ?? 0) + amount;
+    if (!Number.isSafeInteger(amount) || amount < 0 || total > maximum) throw invalid2();
+    counts.set(key, total);
+  };
+  const list = (source, key, maximum, copy) => {
+    if (!Array.isArray(source)) throw invalid2();
+    const length = source.length;
+    take(key, length, maximum);
+    const result = [];
+    for (let index = 0; index < length; index++) result.push(copy(source[index]));
+    return result;
+  };
+  const resources = /* @__PURE__ */ new Map();
+  const vectorBudget = new ForeignVectorBudget();
+  const foreignVector = (source) => ({
+    ...fields(source, ["x", "y", "width", "height", "opacity"]),
+    vector: vectorBudget.take(source.vector).vector
+  });
+  const image = (source) => {
+    const original = source.bytes;
+    if (!(original instanceof Uint8Array) || original.byteLength > 8 * 1024 * 1024) throw invalid2();
+    let bytes = resources.get(original);
+    if (!bytes) {
+      take("raster bytes", original.byteLength, 64 * 1024 * 1024);
+      bytes = new Uint8Array(original.byteLength);
+      bytes.set(original);
+      resources.set(original, bytes);
+    }
+    return {
+      ...fields(source, [
+        "mimeType",
+        "pixelWidth",
+        "pixelHeight",
+        "opacity",
+        "x",
+        "y",
+        "width",
+        "height"
+      ]),
+      bytes
+    };
+  };
+  const style = (source) => {
+    const result = fields(source, [
+      "fill",
+      "lineColor",
+      "lineWidth",
+      "lineCap",
+      "linePattern",
+      "fillOpacity",
+      "lineOpacity",
+      "startArrow",
+      "endArrow",
+      "startArrowSize",
+      "endArrowSize"
+    ]);
+    const dash = source.lineDash;
+    const gradient = source.fillGradient;
+    return {
+      ...result,
+      ...dash === void 0 ? {} : { lineDash: list(dash, "dash values", 15e4, (value) => value) },
+      ...gradient ? {
+        fillGradient: {
+          type: gradient.type,
+          start: [gradient.start[0], gradient.start[1]],
+          end: [gradient.end[0], gradient.end[1]],
+          stops: list(
+            gradient.stops,
+            "gradient stops",
+            1e5,
+            (stop) => fields(stop, ["offset", "color", "opacity"])
+          )
+        }
+      } : {}
+    };
+  };
+  const paragraph = (source) => ({
+    ...fields(source, [
+      "start",
+      "end",
+      "horizontalAlign",
+      "indentLeft",
+      "indentRight",
+      "indentFirst",
+      "spaceBefore",
+      "spaceAfter",
+      "direction"
+    ]),
+    lineSpacing: fields(source.lineSpacing, ["kind", "value"]),
+    ...source.bullet ? { bullet: fields(source.bullet, ["text", "fontFamily", "fontSize", "offset"]) } : {}
+  });
+  const text = (source) => ({
+    ...fields(source, [
+      "plainText",
+      "backgroundColor",
+      "backgroundOpacity",
+      "fontFamily",
+      "fontSize",
+      "color",
+      "horizontalAlign",
+      "verticalAlign",
+      "width",
+      "height"
+    ]),
+    transform: matrix(source.transform),
+    margins: fields(source.margins, ["left", "right", "top", "bottom"]),
+    runs: list(source.runs, "text runs", 1e5, (run) => ({
+      ...fields(run, ["text", "fontFamily", "fontSize", "color"]),
+      bold: !!run.bold,
+      italic: !!run.italic,
+      underline: !!run.underline
+    })),
+    ...source.paragraphs === void 0 ? {} : { paragraphs: list(source.paragraphs, "paragraphs", 5e4, paragraph) }
+  });
+  const seen = /* @__PURE__ */ new Set();
+  const shapes = (source, depth = 0) => {
+    if (depth > 64) {
+      if (!Array.isArray(source) || source.length) throw invalid2();
+      return [];
+    }
+    return list(source, "shapes", 25e3, (shape) => {
+      if (seen.has(shape)) throw invalid2();
+      seen.add(shape);
+      return {
+        ...fields(shape, ["id", "name", "kind", "groupDisplayMode", "width", "height", "hidden"]),
+        transform: matrix(shape.transform),
+        geometry: list(
+          shape.geometry,
+          "geometry",
+          1e5,
+          (geometry) => fields(geometry, ["path", "fill", "stroke"])
+        ),
+        style: style(shape.style),
+        text: text(shape.text),
+        children: shapes(shape.children, depth + 1),
+        ...shape.image ? { image: image(shape.image) } : {},
+        ...shape.foreignVector ? { foreignVector: foreignVector(shape.foreignVector) } : {}
+      };
+    });
+  };
+  return {
+    format: "vsdx",
+    diagnostics: list(
+      model.diagnostics,
+      "diagnostics",
+      2e3,
+      (note) => fields(note, ["code", "message", "severity"])
+    ),
+    pages: list(model.pages, "pages", 256, (page) => ({
+      ...fields(page, ["id", "name", "width", "height", "isBackground", "backgroundPageId"]),
+      shapes: shapes(page.shapes),
+      connectors: []
+    }))
+  };
+}
+
+export { DocumentHistory, EDIT_HISTORY_LIMITS, EMPTY_EDIT_STATE, EMPTY_TEXT_SEARCH, FOREIGN_VECTOR_SCENE_LIMITS, ForeignVectorBudget, MAX_INPUT_BYTES, TEXT_SEARCH_LIMITS, assertShapeDetails, assertViewableDocument, compatibilityNotes, compatibilityText, copySnapshotScene, demoDocument, editErrorMessage, eventKeys, indexDocumentText, inspectForeignVectorResource, isEditCancellation, propertyKeys, searchDocumentText, snapshotEdits, textSearchStatus, validateSearchQuery };