visio-react-viewer 0.0.2 → 0.1.0

package/dist/index.js

@@ -0,0 +1,4131 @@
+import { VISIO_RASTER_IMAGE_LIMITS, VISIO_VISIBILITY_LIMITS, getVisioPageLayers, inspectVisioRasterImage, parseVsdx, resolveVisioPageVisibility, validateVisioForeignVector } from "ooxml-core/visio";
+import { createElement, forwardRef, useEffect, useImperativeHandle, useRef } from "react";
+export * from "visio-core";
+//#region src/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: 100663296,
+	maxEntries: 20
+});
+/** Private controller-owned bytes; transient worker copies and models are separate from this budget. */
+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
+		};
+	}
+};
+//#endregion
+//#region src/edit-commands.ts
+/** Bound cloning and strip arbitrary host properties. Semantic validation belongs to core. */
+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.");
+		}
+	});
+}
+//#endregion
+//#region src/scene-details.ts
+/** Runtime model checks prevent implicit DOM stringification of host-provided objects. */
+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 = (record, names, required = false) => {
+		for (const name of names) if ((required || record[name] !== void 0) && typeof record[name] !== "string") throw new Error("The scene has invalid shape metadata text.");
+	};
+	const booleans = (record, names) => {
+		for (const name of names) if (record[name] !== void 0 && typeof record[name] !== "boolean") throw new Error("The scene has invalid shape metadata flags.");
+	};
+	const count = (record, skipTarget = false) => {
+		const values = Object.entries(record);
+		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 record = row;
+		strings(record, [
+			"id",
+			"name",
+			"valueKind"
+		], true);
+		strings(record, [
+			"label",
+			"rawType",
+			"rawValue",
+			"unit",
+			"error",
+			"format",
+			"prompt",
+			"sortKey"
+		]);
+		booleans(record, ["invisible"]);
+		count(row);
+	}
+	for (const row of links) {
+		const record = row;
+		strings(record, ["id", "name"], true);
+		strings(record, [
+			"description",
+			"address",
+			"subAddress",
+			"sortKey"
+		]);
+		booleans(record, [
+			"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);
+	}
+}
+//#endregion
+//#region src/foreign-vector-budget.ts
+/** UI allocation limits, charged for every instance, including repeated shared resources. */
+var FOREIGN_VECTOR_SCENE_LIMITS = Object.freeze({
+	maxNodes: 1e5,
+	maxCommands: 4e5,
+	maxOperands: 1e6
+});
+/** Count work only after canonical validation. Interpretation and safety remain in core. */
+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
+	};
+}
+/** Invocation-local budget. Never trusts frozen host objects or caches across calls. */
+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;
+	}
+};
+var MAX_DIMENSION = 1e4;
+var MAX_SHAPES = 25e3;
+function finite(value, label, min = -1e4, 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}.`);
+}
+/** Defensive display limits also protect callers supplying their own typed scenes. */
+function assertViewableDocument(model) {
+	if (model.format !== "vsdx" || !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, limit = 4096) => {
+		if (typeof value !== "string" || value.length > limit) 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");
+		}
+		finite(page.width, "page width", .001);
+		finite(page.height, "page height", .001);
+		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) finite(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");
+		}
+		finite(shape.width, "shape width", 0);
+		finite(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]) finite(value, "transform");
+		finite(shape.text.width, "text width", 0);
+		finite(shape.text.height, "text height", 0);
+		finite(shape.text.fontSize, "font size", 0, 100);
+		finite(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) finite(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
+		]) {
+			finite(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) finite(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.");
+		finite(shape.style.fillOpacity, "fill opacity", 0, 1);
+		finite(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]) finite(value, "gradient position", -2e4, 2e4);
+			let offset = -1;
+			for (const stop of gradient.stops) {
+				finite(stop.offset, "gradient stop", 0, 1);
+				finite(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;
+			finite(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
+		]) finite(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
+			]) finite(value, "paragraph position");
+			finite(paragraph.lineSpacing.value, "line spacing", 0, 100);
+			if (paragraph.bullet) {
+				label(paragraph.bullet.text, 1024);
+				label(paragraph.bullet.fontFamily, 1024);
+				finite(paragraph.bullet.fontSize, "bullet size", 0, 100);
+				finite(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.");
+			finite(foreign.x, "foreign vector position");
+			finite(foreign.y, "foreign vector position");
+			finite(foreign.width, "foreign vector width", 0);
+			finite(foreign.height, "foreign vector height", 0);
+			finite(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 > 8388608 || imageBytes > 67108864) throw new Error("The scene exceeds safe image limits.");
+			finite(image.pixelWidth, "image width", 1, 16384);
+			finite(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) finite(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) finite(image.x, "image position");
+			if (image.y !== void 0) finite(image.y, "image position");
+			if (image.width !== void 0) finite(image.width, "image width", 0);
+			if (image.height !== void 0) finite(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.");
+	}
+}
+//#endregion
+//#region src/worker-editor.ts
+function createWorkerEditor(factory, timeoutMs = 2e4) {
+	const create = factory ?? (() => {
+		if (typeof Worker === "undefined") throw new Error("Editing requires browser worker support.");
+		return new Worker(new URL(
+			/* @vite-ignore */
+			new URL("assets/edit-worker-DRgXgRud.js", import.meta.url).href,
+			"" + import.meta.url
+		), { type: "module" });
+	});
+	let cancel;
+	const edit = (bytes, edits) => {
+		cancel?.();
+		if (bytes.byteLength > 33554432) return Promise.reject(/* @__PURE__ */ new Error("This viewer accepts files up to 32 MiB."));
+		let commands;
+		try {
+			commands = snapshotEdits(edits);
+		} catch (error) {
+			return Promise.reject(error);
+		}
+		const copy = Uint8Array.from(bytes);
+		return new Promise((resolve, reject) => {
+			let worker;
+			try {
+				worker = create();
+			} catch (error) {
+				reject(error);
+				return;
+			}
+			let settled = false;
+			const finish = (error, result) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timer);
+				cancel = void 0;
+				try {
+					worker.onmessage = null;
+					worker.onerror = null;
+					worker.terminate();
+				} catch (cause) {
+					error ??= cause instanceof Error ? cause : new Error(String(cause));
+				}
+				if (error) reject(error);
+				else resolve(result);
+			};
+			const timer = setTimeout(() => finish(/* @__PURE__ */ new Error("The diagram exceeded the isolated editing time limit.")), timeoutMs);
+			cancel = () => finish(new DOMException("The diagram edit was cancelled.", "AbortError"));
+			worker.onerror = (event) => finish(new Error(event.message || "The Visio edit worker failed."));
+			worker.onmessage = (event) => {
+				try {
+					const value = event.data;
+					if (value?.ok === true && value.bytes instanceof Uint8Array && value.bytes.byteLength <= 33554432 && value.document && Array.isArray(value.changedParts) && value.changedParts.length <= 1e3 && value.changedParts.every((part) => typeof part === "string" && part.length <= 4096) && Array.isArray(value.diagnostics) && value.diagnostics.length <= 1e3 && value.diagnostics.every((note) => !!note && typeof note === "object" && "code" in note && typeof note.code === "string" && note.code.length <= 256 && "message" in note && typeof note.message === "string" && note.message.length <= 4096)) finish(void 0, value);
+					else {
+						const error = new Error(typeof value?.message === "string" && value.message.length <= 4096 ? value.message : "The Visio edit worker returned an invalid response.");
+						if (typeof value?.code === "string" && value.code.length <= 256) Object.assign(error, { code: value.code });
+						finish(error);
+					}
+				} catch (cause) {
+					finish(cause instanceof Error ? cause : new Error(String(cause)));
+				}
+			};
+			try {
+				worker.postMessage({
+					bytes: copy.buffer,
+					edits: commands
+				}, [copy.buffer]);
+			} catch (cause) {
+				finish(cause instanceof Error ? cause : new Error(String(cause)));
+			}
+		});
+	};
+	edit.cancel = () => cancel?.();
+	return edit;
+}
+//#endregion
+//#region src/viewer-layers.ts
+/** UI limits. Visibility semantics and shape traversal remain in ooxml-core. */
+var VIEWER_LAYER_LIMITS = Object.freeze({
+	overrides: VISIO_VISIBILITY_LIMITS.maxLayers,
+	controls: 200
+});
+var EMPTY_LAYER_OVERRIDES = Object.freeze([]);
+/** Validate before allocating indexes; never expose mutable maps as viewer state. */
+function layerOverrideMaps(model, overrides) {
+	if (!Array.isArray(overrides) || overrides.length > VIEWER_LAYER_LIMITS.overrides) throw new Error("The viewer exceeds the layer override limit.");
+	const pages = new Map(model?.pages.map((page) => [page.id, page]));
+	const known = /* @__PURE__ */ new Map();
+	const result = /* @__PURE__ */ new Map();
+	for (const entry of overrides) {
+		if (!entry || typeof entry.pageId !== "string" || typeof entry.layerId !== "string" || typeof entry.visible !== "boolean") throw new Error("Layer visibility overrides require page and layer IDs and a boolean.");
+		const page = pages.get(entry.pageId);
+		if (!page) throw new Error("The layer override page does not belong to this document.");
+		let ids = known.get(page.id);
+		if (!ids) known.set(page.id, ids = new Set(page.layers?.map((layer) => layer.id)));
+		if (!ids.has(entry.layerId)) throw new Error("The layer does not belong to this page.");
+		let values = result.get(page.id);
+		if (!values) result.set(page.id, values = /* @__PURE__ */ new Map());
+		if (values.has(entry.layerId)) throw new Error("Duplicate layer visibility override.");
+		values.set(entry.layerId, entry.visible);
+	}
+	return result;
+}
+function documentVisibility(model, overrides = EMPTY_LAYER_OVERRIDES) {
+	const maps = layerOverrideMaps(model, overrides);
+	const visible = /* @__PURE__ */ new WeakMap();
+	for (const page of model?.pages ?? []) {
+		const layerVisibilityOverrides = maps.get(page.id);
+		for (const entry of resolveVisioPageVisibility(page, layerVisibilityOverrides ? { layerVisibilityOverrides } : {})) visible.set(entry.shape, !entry.hidden);
+	}
+	return visible;
+}
+function visibleSelection(model, pageIndex, selection, visible) {
+	const page = model?.pages[pageIndex];
+	if (!model || !page || !selection) return false;
+	const stack = [...getVisioPageLayers(model, page.id).find((candidate) => candidate.id === (selection.pageId ?? page.id))?.shapes ?? []];
+	while (stack.length) {
+		const shape = stack.pop();
+		if (shape.id === selection.id) return hasVisibleShapeContent(shape, visible);
+		stack.push(...shape.children);
+	}
+	return false;
+}
+/** Rendering eligibility shared by selection and SVG containers; no format interpretation. */
+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;
+}
+//#endregion
+//#region src/document-text-search.ts
+/** UTF-16 character bounds, applied before copying or case conversion. */
+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
+});
+/** Index canonical text for the current display state. No XML, DOM or layout parsing. */
+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 ? "…" : "");
+					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.`);
+}
+/** One match per shape, literal ECMAScript lowercase comparison; no regex or language collation. */
+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;
+	return (search.activeIndex < 0 ? `${count}${search.resultsTruncated ? "+" : ""} matching shapes` : `${search.activeIndex + 1} of ${count}${search.resultsTruncated ? "+" : ""} matching shapes`) + (search.indexTruncated ? " · Partial text index" : "");
+}
+//#endregion
+//#region src/controller.ts
+var ViewerController = class {
+	parser;
+	listenerError;
+	editor;
+	#state = Object.freeze({
+		document: null,
+		edit: EMPTY_EDIT_STATE,
+		pageIndex: 0,
+		zoom: 1,
+		loading: false,
+		error: null,
+		selectedShape: null,
+		search: EMPTY_TEXT_SEARCH,
+		layerVisibilityOverrides: EMPTY_LAYER_OVERRIDES
+	});
+	#subscribers = /* @__PURE__ */ new Set();
+	#events = /* @__PURE__ */ new Set();
+	#loadId = 0;
+	#destroyed = false;
+	#revision = 0;
+	#documentGeneration = 0;
+	#sourceGeneration = 0;
+	#searchIndex = null;
+	#history = null;
+	#editId = 0;
+	#visible = documentVisibility(null);
+	constructor(parser = parseVsdx, listenerError = (error) => {
+		if (typeof globalThis.reportError === "function") globalThis.reportError(error);
+		else console.error("Visio viewer listener failed:", error);
+	}, editor = createWorkerEditor()) {
+		this.parser = parser;
+		this.listenerError = listenerError;
+		this.editor = editor;
+	}
+	get state() {
+		return this.#state;
+	}
+	/** Accepted document replacements, including the same object, invalidate captured artifacts. */
+	get documentGeneration() {
+		this.#assertAlive();
+		return this.#documentGeneration;
+	}
+	/** Accepted source/model replacements invalidate drafts; edit/undo/redo keep this source epoch. */
+	get sourceGeneration() {
+		this.#assertAlive();
+		return this.#sourceGeneration;
+	}
+	subscribe(listener) {
+		this.#assertAlive();
+		this.#subscribers.add(listener);
+		if (!this.#notify(() => listener(this.#state))) this.#subscribers.delete(listener);
+		return () => this.#subscribers.delete(listener);
+	}
+	onEvent(listener) {
+		this.#assertAlive();
+		this.#events.add(listener);
+		return () => this.#events.delete(listener);
+	}
+	setDocument(document) {
+		this.#assertAlive();
+		if (document) assertViewableDocument(document);
+		const visible = documentVisibility(document);
+		++this.#documentGeneration;
+		++this.#sourceGeneration;
+		this.#invalidateEdit();
+		this.#history = null;
+		this.#loadId++;
+		this.parser.cancel?.();
+		this.#searchIndex = null;
+		this.#visible = visible;
+		this.#change({
+			document,
+			edit: EMPTY_EDIT_STATE,
+			pageIndex: 0,
+			loading: false,
+			error: null,
+			selectedShape: null,
+			search: EMPTY_TEXT_SEARCH,
+			layerVisibilityOverrides: EMPTY_LAYER_OVERRIDES
+		});
+	}
+	setPage(index) {
+		this.#assertAlive();
+		const count = this.#state.document?.pages.length ?? 0;
+		const next = Math.max(0, Math.min(count - 1, Number.isFinite(index) ? Math.trunc(index) : 0));
+		if (next === this.#state.pageIndex) return;
+		if (this.#change({
+			pageIndex: next,
+			selectedShape: null,
+			search: this.#inactiveSearch()
+		})) this.#emit("page-change", next);
+	}
+	setZoom(zoom) {
+		this.#assertAlive();
+		const next = Math.max(.1, Math.min(8, Number.isFinite(zoom) ? zoom : 1));
+		if (next === this.#state.zoom) return;
+		if (this.#change({ zoom: next })) this.#emit("zoom-change", next);
+	}
+	selectShape(shape) {
+		this.#assertAlive();
+		if (shape && !visibleSelection(this.#state.document, this.#state.pageIndex, shape, this.#visible)) return;
+		if (this.#change({
+			selectedShape: shape,
+			search: this.#inactiveSearch()
+		})) this.#emit("shape-select", shape);
+	}
+	/** Override one source-page layer for viewing. null restores its saved display flag. */
+	setLayerVisibility(pageId, layerId, visible) {
+		this.#assertAlive();
+		const page = this.#state.document?.pages.find((candidate) => candidate.id === pageId);
+		if (!page) throw new Error("The layer override page does not belong to this document.");
+		if (!page.layers?.some((layer) => layer.id === layerId)) throw new Error("The layer does not belong to this page.");
+		if (visible !== null && typeof visible !== "boolean") throw new Error("Layer visibility must be boolean or null.");
+		const previous = this.#state.layerVisibilityOverrides;
+		const found = previous.find((entry) => entry.pageId === pageId && entry.layerId === layerId);
+		if (visible === null ? !found : found?.visible === visible) return;
+		const next = previous.filter((entry) => entry !== found);
+		if (visible !== null) next.push(Object.freeze({
+			pageId,
+			layerId,
+			visible
+		}));
+		this.#setLayerOverrides(Object.freeze(next));
+	}
+	/** Reset a source page, or all pages when omitted. Does not modify the document. */
+	resetLayerVisibility(pageId) {
+		this.#assertAlive();
+		if (pageId !== void 0 && !this.#state.document?.pages.some((page) => page.id === pageId)) throw new Error("The layer override page does not belong to this document.");
+		const previous = this.#state.layerVisibilityOverrides;
+		const next = pageId === void 0 ? EMPTY_LAYER_OVERRIDES : Object.freeze(previous.filter((entry) => entry.pageId !== pageId));
+		if (next.length !== previous.length) this.#setLayerOverrides(next);
+	}
+	#setLayerOverrides(layerVisibilityOverrides) {
+		const visible = documentVisibility(this.#state.document, layerVisibilityOverrides);
+		const searchIndex = this.#state.search.query ? indexDocumentText(this.#state.document, (shape) => visible.get(shape) === true) : null;
+		const search = searchIndex ? searchDocumentText(searchIndex, this.#state.search.query) : EMPTY_TEXT_SEARCH;
+		const cleared = !!this.#state.selectedShape && !visibleSelection(this.#state.document, this.#state.pageIndex, this.#state.selectedShape, visible);
+		this.#visible = visible;
+		this.#searchIndex = searchIndex;
+		if (this.#change({
+			layerVisibilityOverrides,
+			search,
+			...cleared ? { selectedShape: null } : {}
+		}) && cleared) this.#emit("shape-select", null);
+	}
+	/** Search does not change the page or selection until explicit result navigation. */
+	setSearchQuery(query) {
+		this.#assertAlive();
+		validateSearchQuery(query);
+		if (query === this.#state.search.query) return;
+		this.#searchIndex ??= indexDocumentText(this.#state.document, (shape) => this.#visible.get(shape) === true);
+		this.#change({ search: searchDocumentText(this.#searchIndex, query) });
+	}
+	selectSearchResult(index) {
+		this.#assertAlive();
+		if (!Number.isSafeInteger(index)) return;
+		const result = this.#state.search.results[index];
+		if (!result) return;
+		const pageChanged = this.#state.pageIndex !== result.pageIndex;
+		if (!this.#change({
+			search: Object.freeze({
+				...this.#state.search,
+				activeIndex: index
+			}),
+			pageIndex: result.pageIndex,
+			...pageChanged ? { selectedShape: null } : {}
+		})) return;
+		const revision = this.#revision;
+		if (pageChanged) this.#emit("page-change", result.pageIndex);
+		if (this.#destroyed || revision !== this.#revision) return;
+		const shape = {
+			id: result.shapeId,
+			name: result.shapeName,
+			pageId: result.pageId
+		};
+		if (this.#change({ selectedShape: shape })) this.#emit("shape-select", shape);
+	}
+	nextSearchResult() {
+		this.#assertAlive();
+		const { activeIndex, results } = this.#state.search;
+		if (results.length) this.selectSearchResult((activeIndex + 1) % results.length);
+	}
+	previousSearchResult() {
+		this.#assertAlive();
+		const { activeIndex, results } = this.#state.search;
+		if (results.length) this.selectSearchResult(activeIndex <= 0 ? results.length - 1 : activeIndex - 1);
+	}
+	#inactiveSearch() {
+		return this.#state.search.activeIndex < 0 ? this.#state.search : Object.freeze({
+			...this.#state.search,
+			activeIndex: -1
+		});
+	}
+	async load(bytes) {
+		this.#assertAlive();
+		if (bytes.byteLength > 33554432) throw new Error("This viewer accepts files up to 32 MiB.");
+		const owned = bytes instanceof Uint8Array ? Uint8Array.from(bytes) : new Uint8Array(bytes.slice(0));
+		return this.loadSource(() => owned);
+	}
+	/** Reading bytes shares the same request epoch and error state as parsing them. */
+	async loadSource(read) {
+		this.#assertAlive();
+		const id = ++this.#loadId;
+		this.#invalidateEdit();
+		this.parser.cancel?.();
+		this.#change({
+			loading: true,
+			error: null,
+			edit: this.#history?.state ?? EMPTY_EDIT_STATE
+		});
+		if (this.#destroyed || id !== this.#loadId) return;
+		let document;
+		let history;
+		let visible;
+		try {
+			const bytes = await read();
+			if (this.#destroyed || id !== this.#loadId) return;
+			if (bytes.byteLength > 33554432) throw new Error("This viewer accepts files up to 32 MiB.");
+			const owned = bytes instanceof Uint8Array ? Uint8Array.from(bytes) : new Uint8Array(bytes.slice(0));
+			history = new DocumentHistory(owned);
+			document = await this.parser(Uint8Array.from(owned));
+			if (this.#destroyed || id !== this.#loadId) return;
+			assertViewableDocument(document);
+			visible = documentVisibility(document);
+		} catch (cause) {
+			if (this.#destroyed || id !== this.#loadId) return;
+			const error = cause instanceof Error ? cause : new Error(String(cause));
+			this.#change({
+				loading: false,
+				error
+			});
+			if (!this.#destroyed && id === this.#loadId) this.#emit("document-error", error);
+			throw error;
+		}
+		this.#history = history;
+		this.#searchIndex = null;
+		this.#visible = visible;
+		++this.#documentGeneration;
+		++this.#sourceGeneration;
+		this.#change({
+			document,
+			edit: history.state,
+			pageIndex: 0,
+			loading: false,
+			error: null,
+			selectedShape: null,
+			search: EMPTY_TEXT_SEARCH,
+			layerVisibilityOverrides: EMPTY_LAYER_OVERRIDES
+		});
+		if (!this.#destroyed && id === this.#loadId) this.#emit("document-load", document);
+	}
+	cancelLoad() {
+		this.#assertAlive();
+		++this.#loadId;
+		this.parser.cancel?.();
+		this.#invalidateEdit();
+		this.#change({
+			loading: false,
+			edit: this.#history?.state ?? EMPTY_EDIT_STATE
+		});
+	}
+	destroy() {
+		if (this.#destroyed) return;
+		this.#destroyed = true;
+		this.#invalidateEdit();
+		this.#history = null;
+		++this.#documentGeneration;
+		++this.#sourceGeneration;
+		++this.#loadId;
+		this.parser.cancel?.();
+		this.#subscribers.clear();
+		this.#events.clear();
+		this.#searchIndex = null;
+		this.#visible = documentVisibility(null);
+		this.#state = Object.freeze({
+			document: null,
+			edit: EMPTY_EDIT_STATE,
+			pageIndex: 0,
+			zoom: 1,
+			loading: false,
+			error: null,
+			selectedShape: null,
+			search: EMPTY_TEXT_SEARCH,
+			layerVisibilityOverrides: EMPTY_LAYER_OVERRIDES
+		});
+	}
+	/** Replace one source-backed local plain-text target. Core decides target support. */
+	async replacePlainText(pageId, shapeId, text) {
+		return this.applyEdits([{
+			type: "replace-plain-text",
+			pageId,
+			shapeId,
+			text
+		}]);
+	}
+	/** Atomic source-backed edits. Core owns protection, dependency and target validation. */
+	async applyEdits(edits) {
+		return this.#mutate("edit", snapshotEdits(edits));
+	}
+	async undo() {
+		return this.#mutate("undo");
+	}
+	async redo() {
+		return this.#mutate("redo");
+	}
+	cancelEdit() {
+		this.#assertAlive();
+		if (!this.#state.edit.busy) return;
+		this.#invalidateEdit();
+		this.parser.cancel?.();
+		this.#change({ edit: this.#history?.state ?? EMPTY_EDIT_STATE });
+	}
+	exportVsdx() {
+		this.#assertAlive();
+		if (!this.#history) throw new Error("Load a VSDX file before downloading a source-backed copy.");
+		if (this.#state.edit.busy || this.#state.loading) throw new Error("Wait for the current document operation before downloading.");
+		return this.#history.export();
+	}
+	#invalidateEdit() {
+		++this.#editId;
+		this.editor.cancel?.();
+	}
+	async #mutate(kind, commands) {
+		this.#assertAlive();
+		const history = this.#history;
+		if (!history) throw new Error("Load a VSDX file before editing. Model-only documents are read only.");
+		if (this.#state.loading || this.#state.edit.busy) throw new Error("Another document operation is in progress.");
+		const target = kind === "undo" ? history.undoTarget : kind === "redo" ? history.redoTarget : void 0;
+		if (kind !== "edit" && !target) return;
+		const id = ++this.#editId;
+		const loadId = this.#loadId;
+		const current = () => !this.#destroyed && id === this.#editId && loadId === this.#loadId && history === this.#history;
+		const assertCurrent = () => {
+			if (!current()) throw new DOMException("The diagram edit was superseded or cancelled.", "AbortError");
+		};
+		this.#change({ edit: Object.freeze({
+			...history.state,
+			busy: true
+		}) });
+		assertCurrent();
+		try {
+			let document;
+			let edited;
+			if (kind === "edit") {
+				edited = await this.editor(Uint8Array.from(history.current.bytes), commands);
+				assertCurrent();
+				if (edited.bytes.byteLength > 33554432) throw new Error("The modified VSDX exceeds 32 MiB.");
+				document = edited.document;
+			} else document = await this.parser(Uint8Array.from(target.bytes));
+			assertCurrent();
+			assertViewableDocument(document);
+			if (edited && !edited.changedParts.length) {
+				this.#change({ edit: history.state });
+				return;
+			}
+			const visible = documentVisibility(document, this.#state.layerVisibilityOverrides);
+			const searchIndex = this.#state.search.query ? indexDocumentText(document, (shape) => visible.get(shape) === true) : null;
+			const search = searchIndex ? searchDocumentText(searchIndex, this.#state.search.query) : EMPTY_TEXT_SEARCH;
+			const selection = this.#state.selectedShape;
+			const selectedShape = selection && visibleSelection(document, this.#state.pageIndex, selection, visible) ? selection : null;
+			if (edited) history.append(edited.bytes, edited.diagnostics);
+			else history.move(target);
+			this.#visible = visible;
+			this.#searchIndex = searchIndex;
+			++this.#documentGeneration;
+			if (this.#change({
+				document,
+				edit: history.state,
+				search,
+				selectedShape,
+				error: null
+			}) && current()) this.#emit("document-change", {
+				document,
+				dirty: history.state.dirty,
+				kind
+			});
+		} catch (cause) {
+			if (!current()) throw new DOMException("The diagram edit was superseded or cancelled.", "AbortError");
+			const error = cause instanceof Error ? cause : new Error(String(cause));
+			this.#change({ edit: Object.freeze({
+				...history.state,
+				error
+			}) });
+			throw error;
+		}
+	}
+	#assertAlive() {
+		if (this.#destroyed) throw new Error("The viewer has been destroyed.");
+	}
+	#change(change) {
+		const revision = ++this.#revision;
+		this.#state = Object.freeze({
+			...this.#state,
+			...change
+		});
+		for (const listener of [...this.#subscribers]) {
+			if (this.#destroyed || revision !== this.#revision) break;
+			if (this.#subscribers.has(listener)) this.#notify(() => listener(this.#state));
+		}
+		return !this.#destroyed && revision === this.#revision;
+	}
+	#notify(callback) {
+		try {
+			callback();
+			return true;
+		} catch (error) {
+			try {
+				this.listenerError(error);
+			} catch {}
+			return false;
+		}
+	}
+	#emit(name, detail) {
+		const revision = this.#revision;
+		for (const listener of [...this.#events]) {
+			if (this.#destroyed || revision !== this.#revision) break;
+			if (this.#events.has(listener)) this.#notify(() => listener(name, detail));
+		}
+	}
+};
+//#endregion
+//#region src/contract.ts
+var propertyKeys = [
+	"document",
+	"pageIndex",
+	"zoom",
+	"showToolbar"
+];
+var eventKeys = [
+	"document-load",
+	"document-change",
+	"document-error",
+	"page-change",
+	"zoom-change",
+	"shape-select"
+];
+//#endregion
+//#region src/worker-parser.ts
+/** One disposable worker per document prevents old parses and long CPU tasks from occupying the UI. */
+function createWorkerParser(factory, timeoutMs = 15e3) {
+	if (!factory && typeof Worker === "undefined") return parseVsdx;
+	const create = factory ?? (() => new Worker(new URL(
+		/* @vite-ignore */
+		new URL("assets/parse-worker-B8EBQQpD.js", import.meta.url).href,
+		"" + import.meta.url
+	), { type: "module" }));
+	let cancel;
+	const parse = (bytes) => {
+		cancel?.();
+		if (bytes.byteLength > 33554432) return Promise.reject(/* @__PURE__ */ new Error("This viewer accepts files up to 32 MiB."));
+		return new Promise((resolve, reject) => {
+			let worker;
+			try {
+				worker = create();
+			} catch (error) {
+				reject(error);
+				return;
+			}
+			let settled = false;
+			const finish = (error, document) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timer);
+				worker.onmessage = null;
+				worker.onerror = null;
+				worker.terminate();
+				cancel = void 0;
+				if (error) reject(error);
+				else resolve(document);
+			};
+			const timer = setTimeout(() => finish(/* @__PURE__ */ new Error(`The diagram exceeded the ${timeoutMs / 1e3}-second isolated parsing limit.`)), timeoutMs);
+			cancel = () => finish(new DOMException("The diagram load was superseded or cancelled.", "AbortError"));
+			worker.onmessage = (event) => {
+				const result = event.data;
+				if (result.ok && result.document) finish(void 0, result.document);
+				else finish(new Error(result.message ?? "The Visio parser worker returned an invalid response."));
+			};
+			worker.onerror = (event) => finish(new Error(event.message || "The Visio parser worker failed."));
+			try {
+				const copy = bytes instanceof Uint8Array ? Uint8Array.from(bytes) : new Uint8Array(bytes.slice(0));
+				worker.postMessage(copy.buffer, [copy.buffer]);
+			} catch (cause) {
+				finish(cause instanceof Error ? cause : new Error(String(cause)));
+			}
+		});
+	};
+	parse.cancel = () => cancel?.();
+	return parse;
+}
+//#endregion
+//#region src/render-fill.ts
+var gradientId = 0;
+function fillPaint(style, defs) {
+	if (!style.fillGradient) return safeColor(style.fill, "#fff");
+	const gradient = svgElement("linearGradient"), paint = style.fillGradient;
+	gradient.id = `visio-fill-${++gradientId}`;
+	gradient.setAttribute("gradientUnits", "userSpaceOnUse");
+	gradient.setAttribute("x1", String(paint.start[0]));
+	gradient.setAttribute("y1", String(paint.start[1]));
+	gradient.setAttribute("x2", String(paint.end[0]));
+	gradient.setAttribute("y2", String(paint.end[1]));
+	for (const color of paint.stops) {
+		const stop = svgElement("stop");
+		stop.setAttribute("offset", String(color.offset));
+		stop.setAttribute("stop-color", safeColor(color.color));
+		stop.setAttribute("stop-opacity", String(color.opacity));
+		gradient.append(stop);
+	}
+	defs.append(gradient);
+	return `url(#${gradient.id})`;
+}
+//#endregion
+//#region src/render-image.ts
+var clipId$1 = 0;
+/** URLs are created only from bounded embedded raster bytes, never from document strings. */
+function renderImage(shape, resources) {
+	if (!shape.image) return void 0;
+	const image = shape.image;
+	const url = resources.imageUrl(image);
+	const node = resources.portable ? svgElement("use") : svgElement("image");
+	const width = image.width ?? shape.width, height = image.height ?? shape.height;
+	const x = image.x ?? 0, y = image.y ?? 0;
+	if (resources.portable) node.setAttributeNS("http://www.w3.org/1999/xlink", "xlink:href", url);
+	else node.setAttribute("href", url);
+	node.setAttribute("width", String(width));
+	node.setAttribute("height", String(height));
+	node.setAttribute("transform", `translate(${x} ${y + height}) scale(1 -1)`);
+	node.setAttribute("preserveAspectRatio", "none");
+	node.setAttribute("opacity", String(image.opacity ?? 1));
+	const group = svgElement("g"), clip = svgElement("clipPath"), rectangle = svgElement("rect");
+	clip.id = `visio-image-clip-${++clipId$1}`;
+	clip.setAttribute("clipPathUnits", "userSpaceOnUse");
+	rectangle.setAttribute("width", String(shape.width));
+	rectangle.setAttribute("height", String(shape.height));
+	clip.append(rectangle);
+	const defs = svgElement("defs");
+	defs.append(clip);
+	group.append(defs);
+	const cropped = svgElement("g");
+	cropped.setAttribute("clip-path", `url(#${clip.id})`);
+	cropped.append(node);
+	group.append(cropped);
+	return group;
+}
+//#endregion
+//#region src/render-foreign-vector.ts
+var NS$1 = "http://www.w3.org/2000/svg";
+var nextResource = 0;
+var pathData = (commands) => commands.map(({ command, values }) => `${command}${values.length ? " " + values.join(" ") : ""}`).join(" ");
+/** Render an independently validated inert scene. Never forwards source tags, IDs or attributes. */
+function renderForeignVector(source, owner = document, budget = new ForeignVectorBudget()) {
+	const scene = budget.take(source).vector;
+	const element = (tag) => owner.createElementNS(NS$1, tag);
+	const root = element("svg"), defs = element("defs"), prefix = `visio-vector-${++nextResource}-`;
+	root.setAttribute("viewBox", `0 0 ${scene.width} ${scene.height}`);
+	root.setAttribute("width", String(scene.width));
+	root.setAttribute("height", String(scene.height));
+	root.setAttribute("preserveAspectRatio", "none");
+	root.setAttribute("overflow", "hidden");
+	const transform = (node, matrix) => node.setAttribute("transform", `matrix(${matrix.join(" ")})`);
+	const clip = (node, index) => {
+		if (index !== void 0) node.setAttribute("clip-path", `url(#${prefix}${index})`);
+	};
+	const clipPath = (item) => {
+		const path = element("path");
+		path.setAttribute("d", pathData(item.commands));
+		path.setAttribute("clip-rule", item.clipRule);
+		transform(path, item.matrix);
+		clip(path, item.clipIndex);
+		return path;
+	};
+	scene.clips.forEach((item, index) => {
+		const path = element("clipPath");
+		path.id = `${prefix}${index}`;
+		path.setAttribute("clipPathUnits", "userSpaceOnUse");
+		transform(path, item.matrix);
+		clip(path, item.clipIndex);
+		for (const child of item.items) path.append(clipPath(child));
+		defs.append(path);
+	});
+	root.append(defs);
+	const draw = (item) => {
+		if (item.kind === "group") {
+			const group = element("g");
+			transform(group, item.matrix);
+			clip(group, item.clipIndex);
+			for (const child of item.items) group.append(draw(child));
+			return group;
+		}
+		const path = element("path"), paint = item.paint;
+		path.setAttribute("d", pathData(item.commands));
+		transform(path, item.matrix);
+		clip(path, item.clipIndex);
+		for (const [name, value] of [
+			["fill", paint.fill],
+			["stroke", paint.stroke],
+			["fill-rule", paint.fillRule],
+			["stroke-width", paint.strokeWidth],
+			["stroke-miterlimit", paint.strokeMiterlimit],
+			["stroke-linecap", paint.strokeLinecap],
+			["stroke-linejoin", paint.strokeLinejoin],
+			["opacity", paint.opacity],
+			["fill-opacity", paint.fillOpacity],
+			["stroke-opacity", paint.strokeOpacity]
+		]) path.setAttribute(name, String(value));
+		return path;
+	};
+	for (const item of scene.items) root.append(draw(item));
+	return root;
+}
+//#endregion
+//#region src/render-foreign-vector-shape.ts
+var clipId = 0;
+/** Core supplies shape-local placement; converter coordinates have a downward Y axis. */
+function renderForeignVectorShape(shape, budget) {
+	const foreign = shape.foreignVector;
+	if (!foreign) return void 0;
+	const node = renderForeignVector(foreign.vector, document, budget);
+	node.setAttribute("width", String(foreign.width));
+	node.setAttribute("height", String(foreign.height));
+	node.setAttribute("transform", `translate(${foreign.x} ${foreign.y + foreign.height}) scale(1 -1)`);
+	node.setAttribute("opacity", String(foreign.opacity));
+	const group = svgElement("g"), defs = svgElement("defs"), clip = svgElement("clipPath"), rectangle = svgElement("rect"), cropped = svgElement("g");
+	clip.id = `visio-vector-frame-${++clipId}`;
+	clip.setAttribute("clipPathUnits", "userSpaceOnUse");
+	rectangle.setAttribute("width", String(shape.width));
+	rectangle.setAttribute("height", String(shape.height));
+	clip.append(rectangle);
+	defs.append(clip);
+	cropped.setAttribute("clip-path", `url(#${clip.id})`);
+	cropped.append(node);
+	group.append(defs, cropped);
+	return group;
+}
+//#endregion
+//#region src/render-resources.ts
+var MAX_EMBEDDED_BYTES = 16777216;
+/** One reference per shared core image resource, with explicit per-render disposal. */
+var RenderResources = class {
+	definitions;
+	#images = /* @__PURE__ */ new Map();
+	#disposed = false;
+	#embeddedBytes = 0;
+	#imageId = 0;
+	constructor(definitions) {
+		this.definitions = definitions;
+	}
+	get portable() {
+		return !!this.definitions;
+	}
+	imageUrl(image) {
+		if (this.#disposed) throw new Error("Render resources have been disposed.");
+		let types = this.#images.get(image.bytes);
+		if (!types) {
+			types = /* @__PURE__ */ new Map();
+			this.#images.set(image.bytes, types);
+		}
+		let url = types.get(image.mimeType);
+		if (!url) {
+			if (this.definitions) {
+				const size = 4 * Math.ceil(image.bytes.byteLength / 3);
+				if (this.#embeddedBytes + size > MAX_EMBEDDED_BYTES) throw new Error("Embedded raster resources exceed the safe SVG export limit.");
+				this.#embeddedBytes += size;
+				const symbol = svgElement("symbol");
+				symbol.id = `visio-export-image-${++this.#imageId}`;
+				symbol.setAttribute("viewBox", "0 0 1 1");
+				symbol.setAttribute("preserveAspectRatio", "none");
+				const node = svgElement("image");
+				node.setAttribute("width", "1");
+				node.setAttribute("height", "1");
+				node.setAttribute("preserveAspectRatio", "none");
+				node.setAttributeNS("http://www.w3.org/1999/xlink", "xlink:href", `data:${image.mimeType};base64,${base64(image.bytes)}`);
+				symbol.append(node);
+				this.definitions.append(symbol);
+				url = `#${symbol.id}`;
+			} else url = URL.createObjectURL(new Blob([Uint8Array.from(image.bytes)], { type: image.mimeType }));
+			types.set(image.mimeType, url);
+		}
+		return url;
+	}
+	dispose() {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		if (!this.portable) for (const types of this.#images.values()) for (const url of types.values()) URL.revokeObjectURL(url);
+		this.#images.clear();
+	}
+};
+function base64(bytes) {
+	const chunks = [];
+	for (let offset = 0; offset < bytes.length; offset += 24576) chunks.push(btoa(String.fromCharCode(...bytes.subarray(offset, offset + 24576))));
+	return chunks.join("");
+}
+//#endregion
+//#region src/arrowheads.ts
+var markerId = 0;
+/** Common Visio line/triangle and concave arrow styles. Sizes remain a documented visual approximation. */
+function applyArrowheads(path, style, defs, warnings) {
+	for (const side of ["start", "end"]) {
+		const code = side === "start" ? style.startArrow : style.endArrow;
+		if (!code) continue;
+		if (![
+			1,
+			2,
+			3,
+			4,
+			5
+		].includes(code)) {
+			warnings.add(`Arrowhead style ${code} is not rendered in this build.`);
+			continue;
+		}
+		const size = side === "start" ? style.startArrowSize ?? 2 : style.endArrowSize ?? 2;
+		const id = `visio-arrow-${++markerId}`;
+		const marker = svgElement("marker");
+		marker.id = id;
+		marker.setAttribute("viewBox", code === 5 ? "-1 -5 11 10" : "0 -4 10 8");
+		marker.setAttribute("refX", "9");
+		marker.setAttribute("refY", "0");
+		marker.setAttribute("orient", "auto-start-reverse");
+		marker.setAttribute("markerUnits", "userSpaceOnUse");
+		const length = (.1 + Math.max(0, Math.min(6, size)) * .045) * (code < 3 ? .85 : 1);
+		marker.setAttribute("markerWidth", String(length));
+		marker.setAttribute("markerHeight", String(length * .8));
+		const glyph = svgElement("path");
+		const filled = code === 2 || code === 4 || code === 5;
+		glyph.setAttribute("d", code === 5 ? "M 0 -4 L 9 0 L 0 4 Q 4 0 0 -4 Z" : filled ? "M 0 -4 L 9 0 L 0 4 Z" : "M 0 -4 L 9 0 L 0 4");
+		glyph.setAttribute("fill", filled ? safeColor(style.lineColor) : "none");
+		glyph.setAttribute("stroke", safeColor(style.lineColor));
+		glyph.setAttribute("stroke-width", "1");
+		if (code === 5) glyph.setAttribute("stroke-linejoin", "round");
+		glyph.setAttribute("opacity", String(style.lineOpacity));
+		marker.append(glyph);
+		defs.append(marker);
+		path.setAttribute(`marker-${side}`, `url(#${id})`);
+		warnings.add("Common arrowhead shapes are rendered; arrowhead sizing is approximate.");
+	}
+}
+//#endregion
+//#region src/text-layout.ts
+var DEFAULT_LIMITS = {
+	maxCharacters: 25e4,
+	maxMeasurements: 5e4,
+	maxLines: 2e4,
+	maxFragments: 3e4,
+	maxShapeCharacters: 5e4,
+	maxShapeMeasurements: 1e4,
+	maxShapeLines: 5e3,
+	maxShapeFragments: 1e4,
+	maxCacheEntries: 4096
+};
+var TextLayoutBudgetError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "TextLayoutBudgetError";
+	}
+};
+/** One bounded measurement cache and work budget per render; shape scopes share both. */
+var TextLayoutBudget = class TextLayoutBudget {
+	limits;
+	cache;
+	parent;
+	#characters = 0;
+	#measurements = 0;
+	#lines = 0;
+	#fragments = 0;
+	constructor(limits, cache, parent) {
+		this.limits = limits;
+		this.cache = cache;
+		this.parent = parent;
+	}
+	static create(options = {}) {
+		const limits = {
+			...DEFAULT_LIMITS,
+			...options
+		};
+		if (Object.values(limits).some((value) => !Number.isSafeInteger(value) || value <= 0)) throw new TextLayoutBudgetError("Text layout limits must be positive safe integers.");
+		return new TextLayoutBudget(Object.freeze(limits), {
+			byMeasure: /* @__PURE__ */ new WeakMap(),
+			entries: 0
+		});
+	}
+	get characters() {
+		return this.#characters;
+	}
+	get measurements() {
+		return this.#measurements;
+	}
+	get lines() {
+		return this.#lines;
+	}
+	get fragments() {
+		return this.#fragments;
+	}
+	/** A shape may be omitted without consuming the rest of the page's budget. */
+	forShape() {
+		return new TextLayoutBudget(Object.freeze({
+			...this.limits,
+			maxCharacters: Math.min(this.limits.maxCharacters, this.limits.maxShapeCharacters),
+			maxMeasurements: Math.min(this.limits.maxMeasurements, this.limits.maxShapeMeasurements),
+			maxLines: Math.min(this.limits.maxLines, this.limits.maxShapeLines),
+			maxFragments: Math.min(this.limits.maxFragments, this.limits.maxShapeFragments)
+		}), this.cache, this);
+	}
+	reserveCharacters(count) {
+		if (!Number.isSafeInteger(count) || count < 0 || this.#characters + count > this.limits.maxCharacters) throw new TextLayoutBudgetError("Text layout exceeds its character budget.");
+		this.parent?.reserveCharacters(count);
+		this.#characters += count;
+	}
+	reserveLine() {
+		if (this.#lines >= this.limits.maxLines) throw new TextLayoutBudgetError("Text layout exceeds its line budget.");
+		this.parent?.reserveLine();
+		++this.#lines;
+	}
+	reserveFragment() {
+		if (this.#fragments >= this.limits.maxFragments) throw new TextLayoutBudgetError("Text layout exceeds its styled-fragment budget.");
+		this.parent?.reserveFragment();
+		++this.#fragments;
+	}
+	reserveMeasurement() {
+		if (this.#measurements >= this.limits.maxMeasurements) throw new TextLayoutBudgetError("Text layout exceeds its measurement budget.");
+		this.parent?.reserveMeasurement();
+		++this.#measurements;
+	}
+	measure(text, run, measure) {
+		if (run.fontFamily.length > 1024 || !Number.isFinite(run.fontSize) || run.fontSize < 0 || run.fontSize > 100) throw new TextLayoutBudgetError("Text layout has an invalid font specification.");
+		const key = text.length <= 256 ? JSON.stringify([
+			run.fontFamily,
+			run.fontSize,
+			run.bold,
+			run.italic,
+			text
+		]) : void 0;
+		const cache = this.cache.byMeasure.get(measure);
+		const cached = key === void 0 ? void 0 : cache?.get(key);
+		if (cached !== void 0) return cached;
+		this.reserveMeasurement();
+		const width = measure(text, run);
+		if (!Number.isFinite(width) || width < 0) throw new TextLayoutBudgetError("Text measurement returned an invalid width.");
+		if (key !== void 0 && this.cache.entries < this.limits.maxCacheEntries) {
+			const entries = cache ?? /* @__PURE__ */ new Map();
+			if (!cache) this.cache.byMeasure.set(measure, entries);
+			entries.set(key, width);
+			++this.cache.entries;
+		}
+		return width;
+	}
+};
+var createTextLayoutBudget = (options = {}) => TextLayoutBudget.create(options);
+var canvas;
+var measureBrowserText = (text, run) => {
+	if (canvas === void 0) canvas = typeof CanvasRenderingContext2D === "undefined" ? null : document.createElement("canvas").getContext("2d");
+	if (!canvas) return Array.from(text).length * run.fontSize * .55;
+	canvas.font = `${run.italic ? "italic " : ""}${run.bold ? "bold " : ""}${run.fontSize * 96}px ${JSON.stringify(run.fontFamily)}`;
+	return canvas.measureText(text).width / 96;
+};
+/** Rendering-only greedy wrapping. Inject one budget across shapes to bound total UI-thread work. */
+function wrapText(runs, width, measure = measureBrowserText, firstLineIndent = 0, budget = createTextLayoutBudget()) {
+	if (!Number.isFinite(width) || !Number.isFinite(firstLineIndent) || runs.length > 1e4) throw new TextLayoutBudgetError("Text layout has invalid dimensions or too many runs.");
+	const scope = budget.forShape();
+	scope.reserveCharacters(runs.reduce((count, run) => count + run.text.length, 0));
+	const boundedMeasure = (value, run) => scope.measure(value, run, measure);
+	const lines = [];
+	const available = () => Math.max(.001, width - (lines.length === 0 ? firstLineIndent : 0));
+	let line = {
+		runs: [],
+		width: 0,
+		height: 0
+	};
+	const finish = () => {
+		if (lines.length >= 5e3) throw new TextLayoutBudgetError("Text layout exceeds the safe line limit.");
+		scope.reserveLine();
+		lines.push(line);
+		line = {
+			runs: [],
+			width: 0,
+			height: 0
+		};
+	};
+	const append = (text, run) => {
+		if (!text) return;
+		const size = boundedMeasure(text, run);
+		const last = line.runs.at(-1);
+		if (last && last.fontFamily === run.fontFamily && last.fontSize === run.fontSize && last.color === run.color && last.bold === run.bold && last.italic === run.italic && last.underline === run.underline) last.text += text;
+		else {
+			scope.reserveFragment();
+			line.runs.push({
+				...run,
+				text
+			});
+		}
+		line.width += size;
+		line.height = Math.max(line.height, run.fontSize * 1.2);
+	};
+	for (const run of runs) {
+		const tokens = run.text.replace(/\r\n?/g, "\n").match(/\n|[^\S\n]+|[^\s]+/gu) ?? [];
+		for (const token of tokens) {
+			if (token === "\n") {
+				line.height = Math.max(line.height, run.fontSize * 1.2);
+				finish();
+				continue;
+			}
+			const whitespace = /^\s+$/u.test(token);
+			const size = boundedMeasure(token, run);
+			if (line.runs.length && line.width + size > available()) {
+				finish();
+				if (whitespace) continue;
+			}
+			if (size <= available() || width <= 0) {
+				append(token, run);
+				continue;
+			}
+			let fragment = "", fragmentWidth = 0;
+			for (const point of token) {
+				const pointWidth = boundedMeasure(point, run);
+				if (fragment && fragmentWidth + pointWidth > available()) {
+					append(fragment, run);
+					finish();
+					fragment = "";
+					fragmentWidth = 0;
+				}
+				fragment += point;
+				fragmentWidth += pointWidth;
+			}
+			append(fragment, run);
+		}
+	}
+	if (line.runs.length || !lines.length) finish();
+	return lines;
+}
+//#endregion
+//#region src/paragraph-layout.ts
+function layoutParagraphs(text, measure = measureBrowserText, budget = createTextLayoutBudget()) {
+	const scope = budget.forShape();
+	const runs = text.runs.length ? text.runs : [{
+		text: text.plainText,
+		fontFamily: text.fontFamily,
+		fontSize: text.fontSize,
+		color: text.color,
+		bold: false,
+		italic: false,
+		underline: false
+	}];
+	if (runs.length > 1e4 || text.plainText.length > scope.limits.maxCharacters) throw new TextLayoutBudgetError("Text layout exceeds its per-shape run/character limit.");
+	const offsets = [0];
+	for (const run of runs) {
+		const next = offsets[offsets.length - 1] + run.text.length;
+		if (next > scope.limits.maxCharacters) throw new TextLayoutBudgetError("Text layout exceeds its per-shape character limit.");
+		offsets.push(next);
+	}
+	const paragraphs = text.paragraphs?.length ? text.paragraphs : [{
+		start: 0,
+		end: text.plainText.length,
+		horizontalAlign: text.horizontalAlign,
+		indentLeft: 0,
+		indentRight: 0,
+		indentFirst: 0,
+		spaceBefore: 0,
+		spaceAfter: 0,
+		lineSpacing: {
+			kind: "multiple",
+			value: 1.2
+		},
+		direction: "ltr"
+	}];
+	if (paragraphs.length > 5e3) throw new TextLayoutBudgetError("Text layout exceeds the safe paragraph limit.");
+	let previousEnd = 0, coveredCharacters = 0;
+	for (const paragraph of paragraphs) {
+		if (!Number.isSafeInteger(paragraph.start) || !Number.isSafeInteger(paragraph.end) || paragraph.start < previousEnd || paragraph.end < paragraph.start || paragraph.end > text.plainText.length) throw new TextLayoutBudgetError("Paragraph ranges must be ordered, non-overlapping and within the text.");
+		previousEnd = paragraph.end;
+		coveredCharacters += paragraph.end - paragraph.start;
+	}
+	scope.reserveCharacters(text.plainText.length - coveredCharacters);
+	const lines = [];
+	let y = 0;
+	for (const paragraph of paragraphs) {
+		const source = sliceRuns(runs, offsets, paragraph.start, paragraph.end);
+		const left = text.margins.left + paragraph.indentLeft, right = text.width - text.margins.right - paragraph.indentRight;
+		const wrapped = wrapText(source, Math.max(.001, right - left), measure, paragraph.indentFirst, scope);
+		y += paragraph.spaceBefore;
+		for (const [index, line] of wrapped.entries()) {
+			if (lines.length >= 5e3) throw new TextLayoutBudgetError("Text layout exceeds the safe line limit.");
+			const minX = left + (index === 0 ? paragraph.indentFirst : 0);
+			const x = paragraph.horizontalAlign === "center" ? (minX + right) / 2 : paragraph.horizontalAlign === "right" ? right : minX;
+			const largestFont = line.runs.reduce((size, run) => Math.max(size, run.fontSize), 0) || text.fontSize;
+			const height = Math.max(.001, paragraph.lineSpacing.kind === "exact" ? paragraph.lineSpacing.value : largestFont * paragraph.lineSpacing.value);
+			lines.push({
+				...line,
+				height,
+				x,
+				y: y + largestFont * .8,
+				availableWidth: Math.max(.001, right - minX),
+				align: paragraph.horizontalAlign,
+				direction: paragraph.direction,
+				last: index === wrapped.length - 1,
+				...index === 0 && paragraph.bullet ? { bullet: {
+					...paragraph.bullet,
+					x: left - paragraph.bullet.offset
+				} } : {}
+			});
+			y += height;
+		}
+		y += paragraph.spaceAfter;
+	}
+	return {
+		lines,
+		height: y
+	};
+}
+function sliceRuns(runs, offsets, start, end) {
+	if (start === end) return [];
+	let lo = 0, hi = runs.length;
+	while (lo < hi) {
+		const mid = lo + hi >>> 1;
+		if (offsets[mid + 1] <= start) lo = mid + 1;
+		else hi = mid;
+	}
+	const result = [];
+	for (let index = lo; index < runs.length && offsets[index] < end; index++) {
+		const run = runs[index], offset = offsets[index];
+		const text = run.text.slice(Math.max(0, start - offset), Math.max(0, end - offset));
+		if (text) result.push({
+			...run,
+			text
+		});
+	}
+	return result;
+}
+//#endregion
+//#region src/render-text.ts
+/** Browser-font layout is approximate until compared with the licensed Visio reference corpus. */
+function renderText(text, warnings, budget) {
+	const group = svgElement("g");
+	group.setAttribute("transform", `${matrix$1(text.transform)} translate(0 ${text.height}) scale(1 -1)`);
+	const backgrounds = svgElement("g"), bullets = svgElement("g");
+	group.append(backgrounds);
+	const node = svgElement("text");
+	node.style.whiteSpace = "pre";
+	node.setAttribute("font-family", text.fontFamily);
+	node.setAttribute("font-size", String(text.fontSize));
+	node.setAttribute("fill", safeColor(text.color));
+	let layout;
+	try {
+		layout = layoutParagraphs(text, void 0, budget);
+	} catch {
+		warnings.add("Text was omitted because it exceeded the safe layout complexity limit.");
+		return group;
+	}
+	const y = text.verticalAlign === "top" ? text.margins.top : text.verticalAlign === "bottom" ? text.height - text.margins.bottom - layout.height : (text.height - layout.height) / 2;
+	for (const line of layout.lines) {
+		if (text.backgroundColor) {
+			const rectangle = svgElement("rect");
+			const width = line.align === "distributed" || line.align === "justify" && !line.last ? line.availableWidth : line.width;
+			const x = line.align === "center" ? line.x - width / 2 : line.align === "right" ? line.x - width : line.x;
+			const font = line.runs.reduce((size, run) => Math.max(size, run.fontSize), 0) || text.fontSize;
+			rectangle.setAttribute("x", String(x));
+			rectangle.setAttribute("y", String(y + line.y - font * .8));
+			rectangle.setAttribute("width", String(width));
+			rectangle.setAttribute("height", String(font * 1.2));
+			rectangle.setAttribute("fill", safeColor(text.backgroundColor));
+			rectangle.setAttribute("fill-opacity", String(text.backgroundOpacity ?? 1));
+			backgrounds.append(rectangle);
+		}
+		const row = svgElement("tspan");
+		row.setAttribute("x", String(line.x));
+		row.setAttribute("y", String(y + line.y));
+		row.setAttribute("direction", line.direction);
+		row.setAttribute("unicode-bidi", "plaintext");
+		const right = line.align === "right";
+		row.setAttribute("text-anchor", line.align === "center" ? "middle" : right === (line.direction === "rtl") ? "start" : "end");
+		if (line.align === "justify" && !line.last) {
+			const spaces = line.runs.reduce((count, run) => count + (run.text.match(/\s/gu)?.length ?? 0), 0);
+			if (spaces) row.setAttribute("word-spacing", String(Math.max(0, (line.availableWidth - line.width) / spaces)));
+		}
+		if (line.align === "distributed") {
+			row.setAttribute("textLength", String(line.availableWidth));
+			row.setAttribute("lengthAdjust", "spacing");
+		}
+		for (const run of line.runs) {
+			const span = svgElement("tspan");
+			span.textContent = run.text;
+			span.setAttribute("font-family", run.fontFamily);
+			span.setAttribute("font-size", String(run.fontSize));
+			span.setAttribute("fill", safeColor(run.color));
+			if (run.bold) span.setAttribute("font-weight", "bold");
+			if (run.italic) span.setAttribute("font-style", "italic");
+			if (run.underline) span.setAttribute("text-decoration", "underline");
+			row.append(span);
+		}
+		node.append(row);
+		if (line.bullet) {
+			const bullet = svgElement("text");
+			bullet.textContent = line.bullet.text;
+			bullet.setAttribute("x", String(line.bullet.x));
+			bullet.setAttribute("y", String(y + line.y));
+			bullet.setAttribute("font-family", line.bullet.fontFamily);
+			bullet.setAttribute("font-size", String(line.bullet.fontSize));
+			bullet.setAttribute("fill", safeColor(text.color));
+			bullets.append(bullet);
+		}
+	}
+	warnings.add("Text metrics and automatic wrapping use browser fonts; Visio line breaking and paragraph layout remain approximate.");
+	if (layout.height > text.height - text.margins.top - text.margins.bottom) warnings.add("Text exceeds its saved text-box height.");
+	group.append(bullets, node);
+	return group;
+}
+//#endregion
+//#region src/render-svg.ts
+var NS = "http://www.w3.org/2000/svg";
+function svgElement(name) {
+	return document.createElementNS(NS, name);
+}
+function safeColor(value, fallback = "#273c46") {
+	return /^(#[\da-f]{3,8}|[a-z]+|(?:rgb|hsl)a?\([\d.,%\s+-]+\))$/i.test(value) ? value : fallback;
+}
+function matrix$1(value) {
+	return `matrix(${value.map((number) => Number.isFinite(number) ? number : 0).join(" ")})`;
+}
+function renderPage(model, page, options = {}) {
+	assertViewableDocument(model);
+	if (!model.pages.includes(page)) throw new Error("The selected page does not belong to this document.");
+	const overrides = layerOverrideMaps(model, options.layerVisibilityOverrides ?? EMPTY_LAYER_OVERRIDES);
+	const visible = overrides.size ? /* @__PURE__ */ new WeakMap() : void 0;
+	const pages = getVisioPageLayers(model, page.id);
+	for (const source of visible ? pages : []) {
+		const layerVisibilityOverrides = overrides.get(source.id);
+		for (const entry of resolveVisioPageVisibility(source, layerVisibilityOverrides ? { layerVisibilityOverrides } : {})) visible.set(entry.shape, !entry.hidden);
+	}
+	const svg = svgElement("svg");
+	if (!options.static) svg.classList.add("paper");
+	svg.setAttributeNS("http://www.w3.org/2000/xmlns/", "xmlns", NS);
+	if (options.static) svg.setAttributeNS("http://www.w3.org/2000/xmlns/", "xmlns:xlink", "http://www.w3.org/1999/xlink");
+	svg.setAttribute("viewBox", `0 0 ${page.width} ${page.height}`);
+	svg.setAttribute("role", options.static ? "img" : "group");
+	svg.setAttribute("aria-label", page.name);
+	const title = svgElement("title");
+	title.textContent = page.name;
+	svg.append(title);
+	const defs = svgElement("defs");
+	svg.append(defs);
+	const root = svgElement("g");
+	root.setAttribute("transform", `translate(0 ${page.height}) scale(1 -1)`);
+	svg.append(root);
+	const context = {
+		defs,
+		warnings: /* @__PURE__ */ new Set(),
+		resources: new RenderResources(options.static ? defs : void 0),
+		nodes: 0,
+		textBudget: createTextLayoutBudget(),
+		vectorBudget: new ForeignVectorBudget(),
+		renderable: /* @__PURE__ */ new WeakMap(),
+		visible,
+		interactive: !options.static
+	};
+	try {
+		for (const layer of pages) for (const shape of layer.shapes) drawShape(shape, root, context, layer.id);
+	} catch (error) {
+		context.resources.dispose();
+		throw error;
+	}
+	if (!options.static) svg.querySelector("[data-shape-id]")?.setAttribute("tabindex", "0");
+	return {
+		svg,
+		warnings: [...context.warnings],
+		dispose: () => context.resources.dispose()
+	};
+}
+function drawShape(shape, parent, context, pageId) {
+	if (!hasVisibleShapeContent(shape, context.visible, context.renderable)) return;
+	if (++context.nodes > 5e4) {
+		context.warnings.add("Some drawing content was omitted because it exceeds the safe rendering node limit.");
+		return;
+	}
+	const group = svgElement("g");
+	group.setAttribute("transform", matrix$1(shape.transform));
+	if (context.interactive) {
+		group.dataset.shapeId = shape.id;
+		group.dataset.shapeName = shape.name;
+		group.dataset.pageId = pageId;
+		group.setAttribute("role", shape.kind === "group" ? "group" : "button");
+		group.setAttribute("tabindex", "-1");
+		group.setAttribute("aria-label", shape.text.plainText || shape.name || `Shape ${shape.id}`);
+	}
+	const title = svgElement("title");
+	title.textContent = shape.text.plainText || shape.name;
+	group.append(title);
+	parent.append(group);
+	const own = () => drawOwn(shape, group, context);
+	const children = () => {
+		for (const child of shape.children) drawShape(child, group, context, pageId);
+	};
+	if (shape.kind === "group" && shape.groupDisplayMode === 0) {
+		children();
+		return;
+	}
+	if (shape.kind === "group" && shape.groupDisplayMode === 2) {
+		children();
+		own();
+		return;
+	}
+	own();
+	children();
+}
+function drawOwn(shape, group, context) {
+	const { warnings, defs, resources } = context;
+	const fill = shape.geometry.some((geometry) => geometry.fill) ? fillPaint(shape.style, defs) : "none";
+	for (const geometry of shape.geometry) {
+		if (++context.nodes > 5e4) {
+			warnings.add("Some drawing content was omitted because it exceeds the safe rendering node limit.");
+			return;
+		}
+		const path = svgElement("path");
+		if (context.interactive) path.dataset.geometry = "";
+		path.setAttribute("d", geometry.path);
+		path.setAttribute("fill", geometry.fill ? fill : "none");
+		path.setAttribute("fill-opacity", String(shape.style.fillOpacity));
+		const stroked = geometry.stroke && shape.style.linePattern !== 0;
+		path.setAttribute("stroke", stroked ? safeColor(shape.style.lineColor) : "none");
+		path.setAttribute("stroke-width", String(shape.style.lineWidth));
+		path.setAttribute("stroke-opacity", String(shape.style.lineOpacity));
+		path.setAttribute("stroke-linejoin", "round");
+		path.setAttribute("stroke-linecap", shape.style.lineCap ?? "round");
+		if (stroked && shape.style.linePattern > 1) {
+			const dash = shape.style.lineDash;
+			if (dash) {
+				path.setAttribute("stroke-dasharray", dash.map((n) => n * shape.style.lineWidth).join(" "));
+				if (shape.style.linePattern <= 23) warnings.add("Some dashed strokes use inferred Visio pattern spacing.");
+			} else warnings.add("An unresolved line pattern is shown as a solid stroke.");
+		}
+		if (stroked) applyArrowheads(path, shape.style, defs, warnings);
+		group.append(path);
+	}
+	const raster = renderImage(shape, resources);
+	if (raster) group.append(raster);
+	const vector = renderForeignVectorShape(shape, context.vectorBudget);
+	if (vector) group.append(vector);
+	if (shape.text.plainText) group.append(renderText(shape.text, warnings, context.textBudget));
+	if (shape.kind === "foreign" && !shape.image && !shape.foreignVector) warnings.add("Embedded or foreign objects are not rendered in this build.");
+}
+//#endregion
+//#region src/shape-inspector.ts
+function selectedShape(document, selection, pageIndex) {
+	if (!document || !selection) return void 0;
+	const stack = [...(selection.pageId ? document.pages.find((page) => page.id === selection.pageId) : document.pages[pageIndex])?.shapes ?? []];
+	while (stack.length) {
+		const shape = stack.pop();
+		if (shape.id === selection.id) return shape;
+		for (const child of shape.children) stack.push(child);
+	}
+}
+function safeExternalHref(value) {
+	if (value.length > 4096 || /[\u0000-\u0020\u007f-\u009f\\]/u.test(value) || /%(?![0-9a-f]{2})/iu.test(value) || /%(?:0[0-9a-f]|1[0-9a-f]|7f|8[0-9a-f]|9[0-9a-f])/iu.test(value)) return void 0;
+	try {
+		const url = new URL(value);
+		if (![
+			"http:",
+			"https:",
+			"mailto:"
+		].includes(url.protocol) || url.username || url.password) return void 0;
+		if (url.protocol !== "mailto:" && (!/^https?:\/\/[^/]/iu.test(value) || /^https?:\/\/[^/?#]*@/iu.test(value))) return void 0;
+		return url.href;
+	} catch {
+		return;
+	}
+}
+function shapeDetails(shape) {
+	const fragment = document.createDocumentFragment();
+	let characters = 1e5, rows = 200, truncated = false;
+	const preview = (value, limit = 2048) => {
+		const length = Math.max(0, Math.min(limit, characters));
+		characters -= Math.min(length, value.length);
+		if (value.length <= length) return value;
+		truncated = true;
+		return value.slice(0, length) + "…";
+	};
+	const title = document.createElement("p");
+	title.textContent = preview(`${shape.name || "Shape"} · ID ${shape.id}`);
+	fragment.append(title);
+	const fields = (shape.shapeData ?? []).filter((field) => !field.invisible);
+	if (fields.length) {
+		const heading = document.createElement("h3");
+		heading.textContent = "Shape data";
+		fragment.append(heading);
+		const list = document.createElement("dl");
+		for (const field of fields) {
+			if (--rows < 0 || characters <= 0) {
+				truncated = true;
+				break;
+			}
+			const label = document.createElement("dt"), value = document.createElement("dd");
+			label.textContent = preview(field.label || field.name || field.id);
+			value.textContent = preview(field.value === void 0 ? field.rawValue ?? "No cached value" : String(field.value)) + (field.valueKind === "date" ? " (serial days)" : field.valueKind === "duration" ? " (days)" : "");
+			if (field.prompt) label.title = preview(field.prompt, 512);
+			if (field.error) value.append(document.createTextNode(preview(` (saved error: ${field.error})`)));
+			list.append(label, value);
+		}
+		fragment.append(list);
+	} else {
+		const empty = document.createElement("p");
+		empty.textContent = "No visible shape data.";
+		fragment.append(empty);
+	}
+	const links = (shape.hyperlinks ?? []).filter((link) => !link.invisible);
+	if (links.length) {
+		const heading = document.createElement("h3");
+		heading.textContent = "Links";
+		fragment.append(heading);
+		const list = document.createElement("ul");
+		for (const link of links) {
+			if (--rows < 0 || characters <= 0) {
+				truncated = true;
+				break;
+			}
+			const item = document.createElement("li"), label = preview(link.description || link.name || link.address || link.subAddress || "Link");
+			const href = link.target.kind === "external" ? safeExternalHref(link.target.href) : void 0;
+			if (href) {
+				const anchor = document.createElement("a");
+				anchor.textContent = label;
+				anchor.href = href;
+				anchor.target = "_blank";
+				anchor.rel = "noopener noreferrer";
+				item.append(anchor);
+			} else {
+				item.textContent = link.target.kind === "internal" ? `${label} (internal target: ${preview(link.target.subAddress)})` : `${label} (unavailable)`;
+				if (link.target.kind === "unresolved") item.title = preview(link.target.reason, 512);
+			}
+			list.append(item);
+		}
+		fragment.append(list);
+	}
+	if (truncated) {
+		const note = document.createElement("p");
+		note.textContent = "Some fields or values are shortened in this preview. Full cached metadata remains in the document model.";
+		fragment.append(note);
+	}
+	return fragment;
+}
+//#endregion
+//#region src/diagnostics.ts
+/** Presentation-only grouping keeps repeated per-shape diagnostics readable without losing counts. */
+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)` : "");
+}
+//#endregion
+//#region src/viewer-input.ts
+var targetShape = (event) => event.target?.closest?.("[data-shape-id]");
+function selection(target) {
+	return target ? {
+		id: target.dataset.shapeId,
+		name: target.dataset.shapeName ?? "",
+		...target.dataset.pageId ? { pageId: target.dataset.pageId } : {}
+	} : null;
+}
+/** Own every DOM listener and abort them together when the surface is disposed. */
+function wireViewerInputs(controls, controller, fit) {
+	const { viewport, commandRoot, pageSelect, searchInput } = controls;
+	const events = new ((viewport.ownerDocument.defaultView?.AbortController) ?? AbortController)();
+	const options = { signal: events.signal };
+	searchInput.addEventListener("input", () => controller.setSearchQuery(searchInput.value), options);
+	searchInput.addEventListener("keydown", (event) => {
+		if (event.isComposing) return;
+		if (event.key === "Enter") {
+			event.preventDefault();
+			if (event.shiftKey) controller.previousSearchResult();
+			else controller.nextSearchResult();
+		}
+		if (event.key === "Escape") {
+			event.preventDefault();
+			controller.setSearchQuery("");
+		}
+	}, options);
+	pageSelect.addEventListener("change", () => controller.setPage(Number(pageSelect.value)), options);
+	commandRoot.addEventListener("click", (event) => {
+		const action = event.target?.closest?.("button")?.dataset.action;
+		if (action === "in") controller.setZoom(controller.state.zoom * 1.25);
+		if (action === "out") controller.setZoom(controller.state.zoom / 1.25);
+		if (action === "fit") fit();
+		if (action === "actual") controller.setZoom(1);
+		if (action === "search-next") controller.nextSearchResult();
+		if (action === "search-previous") controller.previousSearchResult();
+	}, options);
+	viewport.addEventListener("click", (event) => controller.selectShape(selection(targetShape(event))), options);
+	viewport.addEventListener("keydown", (event) => {
+		const target = targetShape(event);
+		if (target && [
+			"ArrowDown",
+			"ArrowRight",
+			"ArrowUp",
+			"ArrowLeft",
+			"Home",
+			"End"
+		].includes(event.key)) {
+			event.preventDefault();
+			const shapes = Array.from(viewport.querySelectorAll("[data-shape-id]")), index = shapes.indexOf(target);
+			const next = event.key === "Home" ? 0 : event.key === "End" ? shapes.length - 1 : (index + (["ArrowRight", "ArrowDown"].includes(event.key) ? 1 : -1) + shapes.length) % shapes.length;
+			for (const shape of shapes) shape.setAttribute("tabindex", "-1");
+			shapes[next]?.setAttribute("tabindex", "0");
+			shapes[next]?.focus();
+			return;
+		}
+		if (target && (event.key === "Enter" || event.key === " ")) {
+			event.preventDefault();
+			controller.selectShape(selection(target));
+			return;
+		}
+		if (event.key === "Escape") controller.selectShape(null);
+		if (event.key === "+" || event.key === "=") {
+			event.preventDefault();
+			controller.setZoom(controller.state.zoom * 1.25);
+		}
+		if (event.key === "-") {
+			event.preventDefault();
+			controller.setZoom(controller.state.zoom / 1.25);
+		}
+		if (event.key === "0") {
+			event.preventDefault();
+			fit();
+		}
+	}, options);
+	return () => events.abort();
+}
+//#endregion
+//#region src/viewer-layer-controls.ts
+var layerControlsTemplate = `<details class="layer-controls" hidden><summary>Layers</summary><p>Display changes only. SVG and print snapshots use saved visibility. Guides, NoShow and unknown hidden reasons remain hidden.</p><div data-layer-list></div><p data-layer-status role="status"></p><button type="button" data-layer-reset="all">Reset all layers</button></details>`;
+/** Static controls and text-only labels. Document strings never become selectors or markup. */
+function renderLayerControls(panel, state) {
+	const model = state.document, page = model?.pages[state.pageIndex];
+	const list = panel.querySelector("[data-layer-list]");
+	const focused = panel.getRootNode().activeElement;
+	const focus = focused && panel.contains(focused) ? { ...focused.dataset } : void 0;
+	const fragment = panel.ownerDocument.createDocumentFragment();
+	const overrides = layerOverrideMaps(model, state.layerVisibilityOverrides);
+	let total = 0, shown = 0;
+	for (const source of model && page ? getVisioPageLayers(model, page.id) : []) {
+		const ids = /* @__PURE__ */ new Set();
+		const fieldset = panel.ownerDocument.createElement("fieldset");
+		const legend = panel.ownerDocument.createElement("legend");
+		const pageLabel = `${source.name.slice(0, 256)} (page ${source.id})`;
+		legend.textContent = `${pageLabel}${source.id === page.id ? "" : " (background)"}`;
+		fieldset.append(legend);
+		let rows = 0;
+		for (const layer of source.layers ?? []) {
+			if (ids.has(layer.id)) continue;
+			ids.add(layer.id);
+			++total;
+			if (shown >= VIEWER_LAYER_LIMITS.controls) continue;
+			++shown;
+			++rows;
+			const row = panel.ownerDocument.createElement("div");
+			const label = panel.ownerDocument.createElement("label");
+			const input = panel.ownerDocument.createElement("input");
+			const override = overrides.get(source.id)?.get(layer.id);
+			input.type = "checkbox";
+			input.dataset.layerId = layer.id;
+			input.dataset.pageId = source.id;
+			input.checked = override ?? layer.visible;
+			const name = `${layer.name.slice(0, 256) || "Layer"} (ID ${layer.id})`;
+			input.setAttribute("aria-label", `${pageLabel}: ${name}`);
+			const description = `${name} · saved ${layer.visible ? "visible" : "hidden"}${override === void 0 ? "" : ` · override ${override ? "visible" : "hidden"}`}`;
+			label.append(input, description);
+			row.append(label);
+			if (override !== void 0) {
+				const reset = panel.ownerDocument.createElement("button");
+				reset.type = "button";
+				reset.textContent = "Reset";
+				reset.dataset.layerReset = "one";
+				reset.dataset.layerId = layer.id;
+				reset.dataset.pageId = source.id;
+				reset.setAttribute("aria-label", `Reset ${pageLabel}: ${name}`);
+				row.append(reset);
+			}
+			fieldset.append(row);
+		}
+		if (rows) fragment.append(fieldset);
+	}
+	list.replaceChildren(fragment);
+	panel.hidden = total === 0 && state.layerVisibilityOverrides.length === 0;
+	panel.querySelector("[data-layer-status]").textContent = total > shown ? `Showing ${shown} of ${total} layers. Other layers are available through the viewer API.` : `${total} layers in this drawing · ${state.layerVisibilityOverrides.length} document display overrides`;
+	panel.querySelector("[data-layer-reset=\"all\"]").disabled = state.layerVisibilityOverrides.length === 0;
+	if (focus) {
+		const controls = [...panel.querySelectorAll("input,button")];
+		const match = (control) => control.dataset.layerId === focus.layerId && control.dataset.pageId === focus.pageId;
+		(controls.find((control) => match(control) && control.dataset.layerReset === focus.layerReset) ?? controls.find(match))?.focus();
+	}
+}
+function wireLayerControls(panel, controller) {
+	const events = new ((panel.ownerDocument.defaultView?.AbortController) ?? AbortController)(), options = { signal: events.signal };
+	panel.addEventListener("change", (event) => {
+		const input = event.target;
+		if (input.matches("input[type=\"checkbox\"]") && input.dataset.pageId !== void 0 && input.dataset.layerId !== void 0) controller.setLayerVisibility(input.dataset.pageId, input.dataset.layerId, input.checked);
+	}, options);
+	panel.addEventListener("click", (event) => {
+		const button = event.target.closest("button[data-layer-reset]");
+		if (!button || !panel.contains(button)) return;
+		if (button.dataset.layerReset === "all") controller.resetLayerVisibility();
+		else if (button.dataset.pageId !== void 0 && button.dataset.layerId !== void 0) controller.setLayerVisibility(button.dataset.pageId, button.dataset.layerId, null);
+	}, options);
+	return () => events.abort();
+}
+//#endregion
+//#region src/styles.ts
+/** Inherited public tokens use local fallback aliases so host themes are never shadowed. */
+var viewerStyles = `
+:host {
+  --_vv-bg:var(--vv-background,#eceae8); --_vv-surface:var(--vv-surface,#fff);
+  --_vv-secondary:var(--vv-secondary,#f3f2f1); --_vv-ink:var(--vv-ink,#1f1f1f);
+  --_vv-muted:var(--vv-muted,#605e5c); --_vv-border:var(--vv-border,#e1dfdd);
+  --_vv-accent:var(--vv-accent,#3955a3); --_vv-accent-soft:var(--vv-accent-soft,rgba(57,85,163,.10));
+  display:flex; flex-direction:column; min-width:0; min-height:320px; height:100%; overflow:hidden;
+  color:var(--_vv-ink); background:var(--_vv-bg); font:12px/1.5 "Segoe UI",Arial,sans-serif; contain:layout;
+}
+* { box-sizing:border-box; }
+[hidden] { display:none !important; }
+button,select,input,textarea { font:inherit; color:inherit; border:1px solid var(--_vv-border); background:var(--_vv-surface); border-radius:4px; min-height:28px; padding:3px 8px; }
+button { cursor:pointer; }
+button:hover:enabled { background:var(--_vv-accent-soft); border-color:var(--_vv-accent); }
+button:disabled { opacity:.4; cursor:default; }
+button:focus-visible,select:focus-visible,input:focus-visible,textarea:focus-visible,summary:focus-visible,[tabindex]:focus-visible { outline:2px solid var(--vv-focus,var(--_vv-accent)); outline-offset:2px; }
+button[aria-pressed="true"] { color:var(--_vv-accent); background:var(--_vv-accent-soft); }
+.toolbar { flex:none; min-width:0; border-bottom:1px solid var(--_vv-border); background:var(--_vv-surface); }
+.ribbon-primary { height:32px; display:flex; align-items:center; gap:6px; padding:2px 8px; }
+.page-picker { display:flex; min-width:0; align-items:center; gap:8px; color:var(--_vv-muted); font-size:11px; }
+.page-picker select { width:190px; max-width:42vw; height:26px; min-height:26px; padding:2px 6px; font-size:11px; color:var(--_vv-ink); }
+.page-stepper { display:flex; align-items:center; gap:2px; }
+.page-stepper button { width:26px; height:26px; min-height:26px; padding:0; font-size:18px; line-height:22px; background:transparent; border-color:transparent; }
+.spacer { flex:1; }
+.local-label { color:var(--_vv-muted); font-size:10px; white-space:nowrap; }
+.ribbon-tabs { height:35px; display:flex; align-items:stretch; padding:0 4px; border-bottom:1px solid var(--_vv-border); }
+.ribbon-tabs button { position:relative; min-height:34px; padding:7px 14px; border:0; border-radius:0; background:transparent; color:var(--_vv-muted); font-size:12px; font-weight:500; }
+.ribbon-tabs button[aria-selected="true"] { color:var(--_vv-accent); }
+.ribbon-tabs button[aria-selected="true"]::after { content:""; position:absolute; inset:auto 0 -1px; height:2.5px; background:var(--_vv-accent); }
+.ribbon-content { min-height:82px; display:flex; align-items:stretch; gap:0; padding:2px 4px; overflow-x:auto; }
+.ribbon-group { display:flex; flex-direction:column; justify-content:space-between; flex:none; gap:2px; padding:3px 10px 4px; border-right:1px solid var(--_vv-border); }
+.group-label { font-size:10px; line-height:12px; color:var(--_vv-muted); text-align:center; }
+.ribbon-actions { display:flex; align-items:stretch; gap:2px; flex:1; }
+.ribbon-command { display:flex; flex-direction:column; justify-content:center; align-items:center; gap:2px; min-width:70px; padding:2px 6px; border-color:transparent; background:transparent; font-size:11px; white-space:nowrap; }
+.command-icon { display:grid; place-items:center; width:26px; height:26px; color:var(--_vv-accent); }
+.command-icon::before { content:""; width:24px; height:24px; background:currentColor; mask:var(--command-symbol) center / contain no-repeat; }
+[data-icon="selection"] { --command-symbol:url("data:image/svg+xml,%3Csvg%20viewBox%3D%220%200%2024%2024%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20fill%3D%22none%22%20stroke%3D%22black%22%20stroke-width%3D%221.6%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%3E%3Cpath%20d%3D%22m5%203%2013%209-6%201-3%206z%22%2F%3E%3C%2Fsvg%3E"); }
+[data-icon="edit"] { --command-symbol:url("data:image/svg+xml,%3Csvg%20viewBox%3D%220%200%2024%2024%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20fill%3D%22none%22%20stroke%3D%22black%22%20stroke-width%3D%221.6%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%3E%3Cpath%20d%3D%22M4%205h16M12%205v14M8%2019h8%22%2F%3E%3C%2Fsvg%3E"); }
+[data-icon="layers"] { --command-symbol:url("data:image/svg+xml,%3Csvg%20viewBox%3D%220%200%2024%2024%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20fill%3D%22none%22%20stroke%3D%22black%22%20stroke-width%3D%221.6%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%3E%3Cpath%20d%3D%22m3%208%209-5%209%205-9%205zM3%2012l9%205%209-5M3%2016l9%205%209-5%22%2F%3E%3C%2Fsvg%3E"); }
+[data-icon="pages"] { --command-symbol:url("data:image/svg+xml,%3Csvg%20viewBox%3D%220%200%2024%2024%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20fill%3D%22none%22%20stroke%3D%22black%22%20stroke-width%3D%221.6%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%3E%3Crect%20x%3D%225%22%20y%3D%223%22%20width%3D%2214%22%20height%3D%2218%22%20rx%3D%221%22%2F%3E%3Cpath%20d%3D%22M8%208h8M8%2012h8M8%2016h5%22%2F%3E%3C%2Fsvg%3E"); }
+[data-icon="inspector"] { --command-symbol:url("data:image/svg+xml,%3Csvg%20viewBox%3D%220%200%2024%2024%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20fill%3D%22none%22%20stroke%3D%22black%22%20stroke-width%3D%221.6%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%3E%3Crect%20x%3D%223%22%20y%3D%224%22%20width%3D%2218%22%20height%3D%2216%22%20rx%3D%221%22%2F%3E%3Cpath%20d%3D%22M14%204v16M17%208h1M17%2012h1M17%2016h1%22%2F%3E%3C%2Fsvg%3E"); }
+[data-icon="notes"] { --command-symbol:url("data:image/svg+xml,%3Csvg%20viewBox%3D%220%200%2024%2024%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20fill%3D%22none%22%20stroke%3D%22black%22%20stroke-width%3D%221.6%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%3E%3Cpath%20d%3D%22M4%204h16v12H9l-5%204z%22%2F%3E%3Cpath%20d%3D%22M8%208h8M8%2012h5%22%2F%3E%3C%2Fsvg%3E"); }
+.ribbon-command[data-chrome="edit"] .command-icon { font-family:ui-serif,Georgia,serif; text-decoration:underline; text-decoration-thickness:1px; text-underline-offset:3px; }
+.ribbon-hint { align-self:center; flex:none; margin:0; padding:0 16px; font-size:11px; line-height:18px; color:var(--_vv-muted); }
+.search-group { width:330px; }
+.search-controls { display:flex; align-items:center; gap:4px; flex-wrap:wrap; }
+.search-controls label { display:flex; align-items:center; min-width:0; gap:6px; flex:1; font-size:11px; }
+.search-controls input { width:100%; min-width:0; padding:3px 6px; font-size:11px; }
+.search-controls button { padding:3px 6px; font-size:10px; background:var(--_vv-secondary); }
+.search-controls [role="status"] { display:block; width:100%; min-height:15px; font-size:10px; line-height:15px; color:var(--_vv-muted); overflow:hidden; white-space:nowrap; text-overflow:ellipsis; }
+.workspace { position:relative; display:flex; flex:1; min-width:0; min-height:0; overflow:hidden; }
+.page-rail { flex:0 0 180px; width:180px; min-width:0; overflow:auto; border-right:1px solid var(--_vv-border); background:var(--_vv-secondary); }
+.pane-heading { height:37px; display:flex; align-items:center; justify-content:space-between; gap:8px; padding:8px 10px; border-bottom:1px solid var(--_vv-border); font-size:11px; font-weight:600; }
+.pane-heading [data-page-count],.inspector-kind { color:var(--_vv-muted); font-size:10px; font-weight:400; }
+.page-list { list-style:none; padding:8px 5px; margin:0; display:flex; flex-direction:column; gap:4px; }
+.page-link { display:flex; align-items:center; position:relative; width:100%; min-width:0; gap:4px; padding:4px 5px 4px 2px; border:0; border-radius:0; background:transparent; color:var(--_vv-muted); text-align:left; }
+.page-link[aria-current="page"] { background:var(--_vv-accent-soft); }
+.page-link[aria-current="page"]::before { content:""; position:absolute; left:0; top:4px; bottom:4px; width:3px; border-radius:0 2px 2px 0; background:var(--_vv-accent); }
+.page-number { flex:0 0 20px; width:20px; padding-right:3px; font-size:10px; text-align:right; }
+.page-card { display:flex; flex-direction:column; align-items:flex-start; min-width:0; width:100%; min-height:98px; gap:3px; padding:10px; border:1px solid var(--_vv-border); border-radius:2px; background:var(--_vv-surface); }
+.page-link[aria-current="page"] .page-card { border-color:var(--_vv-accent); }
+.page-link[aria-current="page"] .page-number { color:var(--_vv-accent); font-weight:600; }
+.page-mark { color:var(--_vv-muted); font-size:20px; line-height:23px; }
+.page-name { color:var(--_vv-ink); font-size:11px; font-weight:500; line-height:16px; overflow-wrap:anywhere; }
+.page-meta { color:var(--_vv-muted); font-size:9px; line-height:14px; }
+.page-empty { margin:12px; color:var(--_vv-muted); font-size:11px; }
+.viewport { position:relative; display:flex; flex-direction:column; flex:1; overflow:auto; min-width:0; min-height:0; padding:16px 4px; background:var(--_vv-bg); }
+.paper { display:block; flex:none; background:white; box-shadow:var(--vv-shadow,0 2px 8px rgb(0 0 0 / 14%)); margin:auto; }
+.paper [data-shape-id] { cursor:pointer; }
+.paper [data-selected="true"] > [data-geometry] { stroke:var(--_vv-accent) !important; stroke-width:.025 !important; }
+.inspector-pane { flex:0 0 288px; width:288px; min-width:0; overflow:auto; border-left:1px solid var(--_vv-border); background:var(--_vv-secondary); }
+.inspector-body { display:flex; flex-direction:column; gap:12px; padding:12px 10px; }
+.inspector-card,.edit-controls,.layer-controls { min-width:0; padding:8px; margin:0; border:1px solid var(--_vv-border); border-radius:4px; background:var(--_vv-surface); font-size:11px; line-height:17px; }
+.document-card h2 { margin:0 0 8px; font-size:10px; font-weight:500; letter-spacing:.5px; text-transform:uppercase; color:var(--_vv-muted); }
+.current-page-name { margin:0 0 8px; font-size:12px; font-weight:500; overflow-wrap:anywhere; }
+.document-card dl { display:grid; grid-template-columns:1fr auto; gap:4px 10px; margin:0; font-size:11px; }
+.document-card dt { color:var(--_vv-muted); }
+.document-card dd { margin:0; text-align:right; overflow-wrap:anywhere; }
+.selection-hint { margin:0; padding:0 2px; color:var(--_vv-muted); font-size:11px; }
+summary { cursor:pointer; min-height:22px; line-height:22px; font-weight:500; }
+summary::marker { color:var(--_vv-muted); font-size:10px; }
+.shape-inspector div { max-height:260px; overflow:auto; }
+.shape-inspector p { margin:6px 0; overflow-wrap:anywhere; }
+.shape-inspector dl { display:grid; grid-template-columns:minmax(60px,1fr) 1.5fr; gap:6px 10px; }
+.shape-inspector dt { font-weight:500; }
+.shape-inspector dd { margin:0; overflow-wrap:anywhere; white-space:pre-wrap; }
+.shape-inspector h3 { margin:12px 0 5px; font-size:11px; }
+.shape-inspector a { color:var(--_vv-accent); overflow-wrap:anywhere; }
+.edit-controls p,.layer-controls p { margin:6px 0; color:var(--_vv-muted); overflow-wrap:anywhere; }
+.edit-controls textarea { display:block; width:100%; resize:vertical; max-height:180px; margin-top:4px; background:var(--_vv-secondary); }
+.edit-controls label { display:block; margin-top:8px; }
+.edit-actions { display:flex; flex-wrap:wrap; gap:4px; margin-top:8px; }
+.edit-actions button { font-size:11px; padding:3px 7px; }
+.edit-actions [data-edit="apply"]:enabled { background:var(--_vv-accent); border-color:var(--_vv-accent); color:var(--vv-accent-ink,#fff); }
+.edit-controls [data-geometry] { min-width:0; margin:8px 0 0; padding:6px; border:1px solid var(--_vv-border); }
+.edit-controls [data-geometry-field] { display:block; width:100%; min-width:0; margin-top:4px; }
+.edit-controls [data-geometry-error] { color:var(--vv-danger,#b42318); }
+.edit-controls [data-edit-error] { color:var(--vv-danger,#b42318); }
+.edit-controls [data-edit-diagnostics] { max-height:100px; overflow:auto; padding-left:16px; }
+.layer-controls [data-layer-list] { max-height:240px; overflow:auto; }
+.layer-controls fieldset { border:1px solid var(--_vv-border); margin:6px 0; padding:6px; min-width:0; }
+.layer-controls legend { max-width:100%; overflow-wrap:anywhere; }
+.layer-controls fieldset div { display:flex; align-items:center; gap:6px; margin:3px 0; }
+.layer-controls label { display:flex; align-items:center; gap:6px; overflow-wrap:anywhere; }
+.layer-controls input { flex-shrink:0; width:16px; height:16px; min-height:16px; padding:0; accent-color:var(--_vv-accent); }
+.notes ul { max-height:220px; overflow:auto; padding-left:17px; margin:6px 0 0; color:var(--_vv-muted); }
+.notes li { margin:5px 0; overflow-wrap:anywhere; }
+.notes-strip { flex:none; display:flex; align-items:center; justify-content:space-between; min-height:25.5px; padding:0 12px; border-top:1px solid var(--_vv-border); background:var(--_vv-bg); color:var(--_vv-muted); font-size:10px; }
+.notes-strip button { min-height:24.5px; padding:2px 0; border:0; background:transparent; color:var(--_vv-muted); font-size:11px; }
+.notes-strip button::before { content:"▸"; margin-right:6px; }
+.notes-strip button[aria-expanded="true"]::before { content:"▾"; }
+.status { flex:none; display:flex; align-items:center; justify-content:space-between; gap:12px; min-width:0; min-height:29px; padding:0 8px 0 12px; border-top:1px solid var(--_vv-border); color:var(--_vv-muted); background:var(--_vv-surface); font-size:10px; }
+.status-message { display:flex; gap:16px; min-width:0; }
+.status-message span { overflow:hidden; white-space:nowrap; text-overflow:ellipsis; }
+.zoom-controls { display:flex; flex:none; align-items:center; gap:3px; }
+.zoom-controls button { min-height:24px; height:24px; padding:1px 6px; border-color:transparent; background:transparent; font-size:10px; }
+.zoom-controls [data-action="in"],.zoom-controls [data-action="out"] { min-width:24px; padding:0; font-size:17px; line-height:20px; }
+.zoom-divider { width:1px; height:14px; background:var(--_vv-border); margin:0 3px; }
+.zoom { min-width:40px; font-size:10px; text-align:center; font-variant-numeric:tabular-nums; }
+.empty { max-width:360px; margin:60px auto; padding:16px; text-align:center; color:var(--_vv-muted); font-size:12px; }
+.empty strong { display:block; color:var(--_vv-ink); font-size:18px; font-weight:500; margin-bottom:8px; }
+@media(max-width:1100px) { .ribbon-hint { display:none; } [data-diagnostics] { display:none; } }
+@media(max-width:760px) {
+  button,select,input,textarea { min-height:44px; }
+  button { min-width:44px; }
+  summary { min-height:44px; line-height:44px; }
+  .ribbon-primary { height:52px; padding:4px 8px; }
+  .page-picker { flex:1; }
+  .page-picker select { width:100%; max-width:none; min-height:44px; height:44px; font-size:12px; }
+  .page-stepper button { width:44px; min-height:44px; height:44px; }
+  .local-label,.ribbon-primary>.spacer { display:none; }
+  .ribbon-tabs { height:44px; }
+  .ribbon-tabs button { min-height:44px; padding:8px 16px; }
+  .ribbon-content { min-height:86px; }
+  .ribbon-group { padding:4px 8px; }
+  .search-group { width:100%; border-right:0; }
+  .search-controls { gap:4px; }
+  .search-controls label { font-size:12px; }
+  .search-controls input { font-size:12px; }
+  .search-controls button { min-width:44px; font-size:0; padding:3px; }
+  .search-controls [data-action="search-previous"]::before { content:"‹"; font-size:22px; }
+  .search-controls [data-action="search-next"]::before { content:"›"; font-size:22px; }
+  #home-panel>.ribbon-group:not(.search-group) { display:none; }
+  .ribbon-command { min-width:90px; }
+  .workspace { display:block; overflow:auto; }
+  .page-rail { width:100%; max-height:190px; border-right:0; border-bottom:1px solid var(--_vv-border); }
+  .page-list { flex-direction:row; overflow-x:auto; }
+  .page-list li { flex:0 0 155px; }
+  .page-card { min-height:86px; }
+  .viewport { height:340px; min-height:260px; padding:16px 4px; }
+  .inspector-pane { width:100%; overflow:visible; border-left:0; border-top:1px solid var(--_vv-border); }
+  .inspector-body { gap:8px; padding:10px; }
+  .inspector-card,.edit-controls,.layer-controls { font-size:12px; }
+  .layer-controls label { min-height:44px; }
+  .layer-controls input { min-width:20px; width:20px; height:20px; min-height:20px; }
+  .notes-strip { min-height:44px; padding:0 10px; }
+  .notes-strip button { min-height:44px; }
+  .status { flex-wrap:wrap; gap:0; padding:4px 8px; }
+  .status-message { width:100%; min-height:18px; }
+  .zoom-controls { justify-content:flex-end; width:100%; }
+  .zoom-controls button { min-height:44px; height:44px; min-width:44px; font-size:11px; }
+  .zoom-controls [data-action="in"],.zoom-controls [data-action="out"] { min-width:44px; font-size:20px; }
+  .zoom { font-size:11px; }
+}
+@media(pointer:coarse) {
+  button,select,input,textarea { min-height:44px; }
+  button { min-width:44px; }
+  summary,.layer-controls label { min-height:44px; line-height:44px; }
+  .ribbon-primary { min-height:52px; height:52px; }
+  .page-picker select,.page-stepper button { min-height:44px; height:44px; }
+  .page-stepper button { min-width:44px; }
+  .ribbon-tabs { min-height:44px; height:44px; }
+  .ribbon-tabs button { min-height:44px; }
+  .ribbon-content { min-height:96px; }
+  .search-group { width:380px; max-width:100%; }
+  .zoom-controls button,.notes-strip button { min-height:44px; height:44px; }
+  .zoom-controls [data-action="in"],.zoom-controls [data-action="out"] { min-width:44px; }
+  .layer-controls input { min-height:20px; }
+}
+@media(prefers-reduced-motion:reduce) { * { scroll-behavior:auto !important; } }
+`;
+//#endregion
+//#region src/edit-error.ts
+/** Core error codes remain visible for a refused transaction; document content is plain text. */
+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;
+}
+/** Superseded worker/load operations are cancellation, not a refused document edit. */
+function isEditCancellation(error) {
+	return !!error && typeof error === "object" && "name" in error && error.name === "AbortError";
+}
+//#endregion
+//#region src/viewer-geometry-controls.ts
+var geometryControlsTemplate = `<fieldset data-geometry><legend>Geometry (experimental)</legend><p>Pin X/Y use drawing inches, bottom-left origin, Y up. Resize holds the rotation pin fixed. Core rejects unsupported formulas, protected cells, unsafe group/master dependencies and referenced deletion. Native Visio reopen fidelity is unverified.</p><label>New rectangle ID <input data-geometry-field="id" type="text" maxlength="256"></label><label>Rectangle text (optional) <input data-geometry-field="text" type="text" maxlength="1000000"></label><label>Pin X (inches) <input data-geometry-field="x" type="number" step="any"></label><label>Pin Y (inches) <input data-geometry-field="y" type="number" step="any"></label><label>Width (inches) <input data-geometry-field="width" type="number" min="0" step="any"></label><label>Height (inches) <input data-geometry-field="height" type="number" min="0" step="any"></label><div class="edit-actions"><button type="button" data-geometry-action="create-rectangle">Create rectangle</button><button type="button" data-geometry-action="move-shape">Move selected</button><button type="button" data-geometry-action="resize-shape">Resize selected</button><button type="button" data-geometry-action="delete-shape">Delete selected</button></div><p data-geometry-error role="alert" hidden></p></fieldset>`;
+/** Collect explicit coordinates; never infer a Visio pin from rendered SVG transforms. */
+var ViewerGeometryControls = class {
+	panel;
+	controller;
+	draftChanged;
+	#fields;
+	#buttons;
+	#error;
+	#identity = "";
+	#request = 0;
+	constructor(panel, controller, draftChanged = () => {}) {
+		this.panel = panel;
+		this.controller = controller;
+		this.draftChanged = draftChanged;
+		const field = (name) => panel.querySelector(`[data-geometry-field="${name}"]`);
+		this.#fields = {
+			id: field("id"),
+			text: field("text"),
+			x: field("x"),
+			y: field("y"),
+			width: field("width"),
+			height: field("height")
+		};
+		this.#buttons = [...panel.querySelectorAll("[data-geometry-action]")];
+		this.#error = panel.querySelector("[data-geometry-error]");
+	}
+	wire() {
+		const events = new ((this.panel.ownerDocument.defaultView?.AbortController) ?? AbortController)();
+		for (const field of Object.values(this.#fields)) field.addEventListener("input", () => {
+			this.render(this.controller.state);
+			this.draftChanged();
+		}, { signal: events.signal });
+		for (const button of this.#buttons) button.addEventListener("click", () => {
+			this.#run(button);
+		}, { signal: events.signal });
+		return () => {
+			++this.#request;
+			events.abort();
+		};
+	}
+	async #run(button) {
+		if (button.disabled) return;
+		const state = this.controller.state;
+		const pageId = state.selectedShape?.pageId ?? state.document?.pages[state.pageIndex]?.id;
+		if (pageId === void 0) return;
+		const type = button.dataset.geometryAction;
+		const shapeId = type === "create-rectangle" ? this.#fields.id.value : state.selectedShape?.id;
+		if (!shapeId) return;
+		const x = this.#fields.x.valueAsNumber, y = this.#fields.y.valueAsNumber;
+		const width = this.#fields.width.valueAsNumber, height = this.#fields.height.valueAsNumber;
+		const target = {
+			pageId,
+			shapeId
+		};
+		const command = type === "create-rectangle" ? {
+			type,
+			...target,
+			x,
+			y,
+			width,
+			height,
+			...this.#fields.text.value ? { text: this.#fields.text.value } : {}
+		} : type === "move-shape" ? {
+			type,
+			...target,
+			x,
+			y
+		} : type === "resize-shape" ? {
+			type,
+			...target,
+			width,
+			height
+		} : {
+			type: "delete-shape",
+			...target
+		};
+		const request = ++this.#request;
+		this.#error.hidden = true;
+		try {
+			await this.controller.applyEdits([command]);
+			if (request === this.#request) {
+				this.reset();
+				this.render(this.controller.state);
+				this.draftChanged();
+			}
+		} catch (error) {
+			if (request === this.#request && !isEditCancellation(error)) {
+				this.#error.textContent = editErrorMessage(error);
+				this.#error.hidden = false;
+			}
+		}
+	}
+	get hasDraft() {
+		return Object.values(this.#fields).some((field) => field.value !== "");
+	}
+	reset() {
+		++this.#request;
+		this.#error.hidden = true;
+		for (const field of Object.values(this.#fields)) field.value = "";
+	}
+	render(state) {
+		const pageId = state.selectedShape?.pageId ?? state.document?.pages[state.pageIndex]?.id;
+		const identity = JSON.stringify([
+			this.controller.sourceGeneration,
+			state.pageIndex,
+			pageId,
+			state.selectedShape?.id
+		]);
+		if (identity !== this.#identity) {
+			this.#identity = identity;
+			++this.#request;
+			this.#error.hidden = true;
+			for (const field of Object.values(this.#fields)) field.value = "";
+		}
+		const available = state.edit.sourceAvailable && pageId !== void 0 && !state.loading && !state.edit.busy;
+		for (const field of Object.values(this.#fields)) field.disabled = !available;
+		const position = [this.#fields.x, this.#fields.y].every((field) => Number.isFinite(field.valueAsNumber));
+		const size = [this.#fields.width, this.#fields.height].every((field) => Number.isFinite(field.valueAsNumber) && field.valueAsNumber > 0);
+		for (const button of this.#buttons) {
+			const action = button.dataset.geometryAction;
+			button.disabled = !available || (action === "create-rectangle" ? !this.#fields.id.value || !position || !size : !state.selectedShape || action === "move-shape" && !position || action === "resize-shape" && !size);
+		}
+	}
+};
+//#endregion
+//#region src/viewer-edit-controls.ts
+/** Static markup only. Document text is assigned exclusively through value/textContent. */
+var editControlsTemplate = `<details class="edit-controls"><summary>Edit diagram (experimental)</summary><p id="edit-warning">Experimental source-backed editing. Unsupported targets are rejected. Native Visio compatibility is not verified. Keep your original file.</p><p data-edit-target></p><label for="edit-text">Selected shape text</label><textarea id="edit-text" rows="3" aria-describedby="edit-warning edit-target edit-status"></textarea><div class="edit-actions"><button type="button" data-edit="apply">Apply text</button><button type="button" data-edit="cancel">Cancel</button><button type="button" data-edit="undo">Undo</button><button type="button" data-edit="redo">Redo</button></div><p id="edit-status" role="status" aria-live="polite"></p><p data-edit-error role="alert" hidden></p><ul data-edit-diagnostics></ul>${geometryControlsTemplate}</details>`;
+var ViewerEditControls = class {
+	panel;
+	input;
+	#target;
+	#status;
+	#error;
+	#diagnostics;
+	#buttons;
+	#identity = "";
+	#initial = "";
+	#pageId;
+	#shapeId;
+	#request = 0;
+	#pending = false;
+	#localError;
+	#controller;
+	#geometry;
+	constructor(root, controller) {
+		this.#controller = controller;
+		this.panel = root.querySelector(".edit-controls");
+		this.#geometry = new ViewerGeometryControls(this.panel, controller, () => this.render(controller.state));
+		this.input = this.panel.querySelector("textarea");
+		this.#target = this.panel.querySelector("[data-edit-target]");
+		this.#target.id = "edit-target";
+		this.#status = this.panel.querySelector("#edit-status");
+		this.#error = this.panel.querySelector("[data-edit-error]");
+		this.#diagnostics = this.panel.querySelector("[data-edit-diagnostics]");
+		const button = (name) => this.panel.querySelector(`[data-edit="${name}"]`);
+		this.#buttons = {
+			apply: button("apply"),
+			cancel: button("cancel"),
+			undo: button("undo"),
+			redo: button("redo")
+		};
+	}
+	wire() {
+		const disposeGeometry = this.#geometry.wire();
+		const events = new ((this.panel.ownerDocument.defaultView?.AbortController) ?? AbortController)();
+		const options = { signal: events.signal };
+		this.input.addEventListener("input", () => this.render(this.#controller.state), options);
+		this.input.addEventListener("keydown", (event) => {
+			if (event.isComposing) return;
+			if (event.key === "Escape") {
+				event.preventDefault();
+				this.reset();
+			}
+			if (event.key === "Enter" && (event.ctrlKey || event.metaKey)) {
+				event.preventDefault();
+				this.#buttons.apply.click();
+			}
+		}, options);
+		this.#buttons.cancel.addEventListener("click", () => this.reset(), options);
+		for (const action of [
+			"apply",
+			"undo",
+			"redo"
+		]) this.#buttons[action].addEventListener("click", () => {
+			this.#run(action);
+		}, options);
+		return () => {
+			disposeGeometry();
+			events.abort();
+			++this.#request;
+			this.#pending = false;
+			this.#localError = void 0;
+			this.#identity = "";
+			this.input.value = this.#initial;
+		};
+	}
+	reset(focus = true) {
+		this.#geometry.reset();
+		++this.#request;
+		this.#pending = false;
+		this.#localError = void 0;
+		this.#controller.cancelEdit();
+		this.input.value = this.#initial;
+		this.render(this.#controller.state);
+		if (focus && !this.input.disabled) this.input.focus();
+	}
+	async #run(action) {
+		if (this.#buttons[action].disabled) return;
+		const request = ++this.#request;
+		this.#pending = true;
+		this.#localError = void 0;
+		this.render(this.#controller.state);
+		try {
+			if (action === "apply") {
+				if (this.#pageId === void 0 || this.#shapeId === void 0) return;
+				await this.#controller.replacePlainText(this.#pageId, this.#shapeId, this.input.value);
+			} else await this.#controller[action]();
+		} catch (error) {
+			if (request === this.#request && !isEditCancellation(error)) this.#localError = editErrorMessage(error);
+		} finally {
+			if (request === this.#request) {
+				this.#pending = false;
+				this.render(this.#controller.state);
+			}
+		}
+	}
+	render(state) {
+		this.#geometry.render(state);
+		const selection = state.selectedShape;
+		const pageId = selection?.pageId ?? state.document?.pages[state.pageIndex]?.id;
+		const shape = selectedShape(state.document, selection, state.pageIndex);
+		const identity = JSON.stringify([
+			this.#controller.sourceGeneration,
+			state.pageIndex,
+			pageId,
+			selection?.id
+		]);
+		if (identity !== this.#identity) {
+			this.#identity = identity;
+			++this.#request;
+			this.#pending = false;
+			this.#localError = void 0;
+			this.#pageId = shape ? pageId : void 0;
+			this.#shapeId = shape?.id;
+			this.#initial = shape?.text?.plainText ?? "";
+			this.input.value = this.#initial;
+		} else if (shape) {
+			const dirty = this.input.value !== this.#initial;
+			this.#initial = shape.text?.plainText ?? "";
+			if (!dirty) this.input.value = this.#initial;
+		}
+		const busy = state.loading || state.edit.busy || this.#pending;
+		const available = state.edit.sourceAvailable && !!shape && pageId !== void 0;
+		this.panel.setAttribute("aria-busy", String(busy));
+		this.#target.textContent = shape ? `Page ID: ${pageId} · Shape ID: ${shape.id} · ${shape.name || "Unnamed shape"}` : "Select a shape to replace its plain text.";
+		this.input.disabled = !available || busy;
+		this.#buttons.apply.disabled = !available || busy || this.input.value === this.#initial;
+		this.#buttons.cancel.disabled = !state.edit.busy && !this.#pending && this.input.value === this.#initial && !this.#geometry.hasDraft;
+		this.#buttons.undo.disabled = busy || !state.edit.canUndo;
+		this.#buttons.redo.disabled = busy || !state.edit.canRedo;
+		this.#status.textContent = state.loading ? "Opening diagram…" : busy ? "Updating diagram…" : !state.edit.sourceAvailable ? "Open a .vsdx file to edit or download a VSDX copy. Model-only documents cannot be saved." : `${state.edit.dirty ? "Edited copy" : "Original bytes"}${state.edit.historyTruncated ? " · Earlier undo history was discarded." : ""}`;
+		const error = this.#localError ?? (state.edit.error ? editErrorMessage(state.edit.error) : void 0);
+		this.#error.hidden = !error;
+		this.#error.textContent = error ?? "";
+		this.#diagnostics.replaceChildren(...state.edit.diagnostics.map((diagnostic) => {
+			const item = this.panel.ownerDocument.createElement("li");
+			item.textContent = `${diagnostic.code}: ${diagnostic.message}`;
+			return item;
+		}));
+	}
+};
+//#endregion
+//#region src/viewer-search.ts
+var searchTemplate = `<div class="search-controls" role="search" aria-label="Diagram text search"><label>Find <input type="search" aria-label="Search diagram text" placeholder="Text across pages" maxlength="${TEXT_SEARCH_LIMITS.queryCharacters}" autocomplete="off" spellcheck="false" aria-describedby="search-status"></label><button type="button" data-action="search-previous" aria-label="Previous matching shape">Previous</button><button type="button" data-action="search-next" aria-label="Next matching shape">Next</button><span id="search-status" role="status" aria-live="polite" aria-atomic="true"></span></div>`;
+function searchControls(root) {
+	return {
+		input: root.querySelector("input[type=\"search\"]"),
+		status: root.querySelector("#search-status"),
+		previous: root.querySelector("[data-action=\"search-previous\"]"),
+		next: root.querySelector("[data-action=\"search-next\"]")
+	};
+}
+function renderSearchControls(controls, state) {
+	if (controls.input.value !== state.search.query) controls.input.value = state.search.query;
+	controls.input.disabled = !state.document?.pages.length;
+	controls.previous.disabled = controls.next.disabled = !state.search.results.length;
+	controls.status.textContent = state.document ? textSearchStatus(state.search) : "Open a diagram to search";
+	const result = state.search.results[state.search.activeIndex];
+	controls.status.title = result ? `${result.pageName} · ${result.shapeName}: ${result.preview}` : "";
+}
+//#endregion
+//#region src/viewer-chrome.ts
+/** Only static application markup belongs here. All document labels are inserted as text. */
+var viewerChromeTemplate = `
+<div class="toolbar" role="group" aria-label="Diagram controls">
+  <div class="ribbon-primary">
+    <label class="page-picker">Page <select aria-label="Page"></select></label>
+    <div class="page-stepper"><button type="button" data-chrome="previous-page" aria-label="Previous page">‹</button><button type="button" data-chrome="next-page" aria-label="Next page">›</button></div>
+    <span class="spacer"></span><span class="local-label">Local workspace</span>
+  </div>
+  <div class="ribbon-tabs" role="tablist" aria-label="Ribbon">
+    <button type="button" id="home-tab" role="tab" aria-selected="true" aria-controls="home-panel" data-tab="home">Home</button>
+    <button type="button" id="view-tab" role="tab" aria-selected="false" aria-controls="view-panel" tabindex="-1" data-tab="view">View</button>
+  </div>
+  <div class="ribbon-content" id="home-panel" role="tabpanel" aria-labelledby="home-tab">
+    <div class="ribbon-group search-group">${searchTemplate}<span class="group-label">Find in drawing</span></div>
+    <div class="ribbon-group"><div class="ribbon-actions">
+      <button class="ribbon-command" type="button" data-chrome="selection"><span class="command-icon" data-icon="selection" aria-hidden="true"></span><span>Shape details</span></button>
+      <button class="ribbon-command" type="button" data-chrome="edit"><span class="command-icon" data-icon="edit" aria-hidden="true"></span><span>Edit text</span></button>
+      <button class="ribbon-command" type="button" data-chrome="layers"><span class="command-icon" data-icon="layers" aria-hidden="true"></span><span>Layers</span></button>
+    </div><span class="group-label">Inspect and edit</span></div>
+    <p class="ribbon-hint">Select a shape to inspect its details.<br>Text editing is experimental.</p>
+  </div>
+  <div class="ribbon-content" id="view-panel" role="tabpanel" aria-labelledby="view-tab" hidden>
+    <div class="ribbon-group"><div class="ribbon-actions">
+      <button class="ribbon-command" type="button" data-chrome="pages" aria-pressed="true" aria-controls="page-rail"><span class="command-icon" data-icon="pages" aria-hidden="true"></span><span>Pages pane</span></button>
+      <button class="ribbon-command" type="button" data-chrome="inspector" aria-pressed="true" aria-controls="inspector-pane"><span class="command-icon" data-icon="inspector" aria-hidden="true"></span><span>Inspector pane</span></button>
+      <button class="ribbon-command" type="button" data-chrome="notes"><span class="command-icon" data-icon="notes" aria-hidden="true"></span><span>Review notes</span></button>
+    </div><span class="group-label">Workspace panes</span></div>
+    <p class="ribbon-hint">Canvas shortcuts: + / − to zoom, 0 to fit.<br>Arrow keys move between focused shapes.</p>
+  </div>
+</div>
+<div class="workspace">
+  <nav id="page-rail" class="page-rail" aria-label="Diagram pages"><div class="pane-heading"><span>Pages</span><span data-page-count>0</span></div><ol class="page-list"></ol><p class="page-empty">Open a drawing to see its pages.</p></nav>
+  <div class="viewport" tabindex="0" role="region" aria-label="Diagram canvas"></div>
+  <aside id="inspector-pane" class="inspector-pane" aria-label="Drawing inspector">
+    <div class="pane-heading"><span>Inspector</span><span class="inspector-kind">Drawing</span></div>
+    <div class="inspector-body">
+      <section class="inspector-card document-card" aria-label="Current page"><h2>Current page</h2><p class="current-page-name" data-page-name>No diagram open</p><dl><dt>Size</dt><dd data-page-size>No page</dd><dt>Shapes</dt><dd data-page-shapes>No shapes</dd></dl></section>
+      <p class="selection-hint">Select a shape on the canvas to see its data and links.</p>
+      <details class="shape-inspector inspector-card" hidden><summary>Selected shape</summary><div></div></details>
+      ${editControlsTemplate}${layerControlsTemplate}
+      <details class="notes inspector-card"><summary>Compatibility notes</summary><ul></ul></details>
+    </div>
+  </aside>
+</div>
+<div class="notes-strip"><button type="button" data-chrome="notes" aria-controls="inspector-pane" aria-expanded="false">Notes<span class="notes-count" data-note-count></span></button><span>Files stay in your browser</span></div>
+<div class="status"><div class="status-message" role="status"><span data-status></span><span data-diagnostics></span></div><div class="zoom-controls" role="group" aria-label="Canvas zoom"><button type="button" data-action="fit">Fit page</button><button type="button" data-action="actual">100%</button><span class="zoom-divider"></span><button type="button" data-action="out" aria-label="Zoom out">−</button><output class="zoom" aria-label="Zoom level">100%</output><button type="button" data-action="in" aria-label="Zoom in">+</button></div></div>`;
+/** Presentation state stays local; page navigation uses the same controller as every binding. */
+var ViewerChrome = class {
+	#root;
+	#controller;
+	#document;
+	#pageList;
+	#rail;
+	#inspector;
+	#notes;
+	#responsive;
+	#pagesManuallyToggled = false;
+	constructor(root, controller) {
+		this.#root = root;
+		this.#controller = controller;
+		this.#pageList = root.querySelector(".page-list");
+		this.#rail = root.querySelector(".page-rail");
+		this.#inspector = root.querySelector(".inspector-pane");
+		this.#notes = root.querySelector(".notes");
+	}
+	wire() {
+		const view = this.#root.ownerDocument.defaultView;
+		const events = new ((view?.AbortController) ?? AbortController)(), options = { signal: events.signal };
+		this.#responsive = view?.matchMedia?.("(max-width: 980px)");
+		const responsive = () => {
+			if (!this.#pagesManuallyToggled) this.#setPane("pages", !this.#responsive?.matches);
+		};
+		responsive();
+		this.#responsive?.addEventListener("change", responsive, options);
+		this.#root.addEventListener("click", (event) => {
+			const button = event.target?.closest?.("button");
+			if (!button || button.disabled) return;
+			const tab = button.dataset.tab;
+			if (tab === "home" || tab === "view") this.#showTab(tab);
+			if (button.dataset.pageIndex !== void 0) this.#controller.setPage(Number(button.dataset.pageIndex));
+			const action = button.dataset.chrome;
+			if (action === "previous-page") this.#controller.setPage(this.#controller.state.pageIndex - 1);
+			if (action === "next-page") this.#controller.setPage(this.#controller.state.pageIndex + 1);
+			if (action === "pages") {
+				this.#pagesManuallyToggled = true;
+				this.#setPane("pages", this.#rail.hidden);
+			}
+			if (action === "inspector") this.#setPane("inspector", this.#inspector.hidden);
+			if (action === "notes" || action === "selection" || action === "edit" || action === "layers") this.#reveal(action);
+		}, options);
+		this.#root.addEventListener("keydown", (event) => {
+			const key = event;
+			const button = event.target?.closest?.("button");
+			if (!button || ![
+				"ArrowLeft",
+				"ArrowRight",
+				"ArrowUp",
+				"ArrowDown",
+				"Home",
+				"End"
+			].includes(key.key)) return;
+			if (button.dataset.tab) {
+				if (key.key === "ArrowUp" || key.key === "ArrowDown") return;
+				key.preventDefault();
+				const tab = key.key === "Home" ? "home" : key.key === "End" ? "view" : button.dataset.tab === "home" ? "view" : "home";
+				this.#showTab(tab);
+				this.#root.querySelector(`[data-tab="${tab}"]`).focus();
+			} else if (button.dataset.pageIndex !== void 0) {
+				key.preventDefault();
+				const pages = [...this.#pageList.querySelectorAll("button")];
+				const current = Number(button.dataset.pageIndex);
+				const next = key.key === "Home" ? 0 : key.key === "End" ? pages.length - 1 : Math.max(0, Math.min(pages.length - 1, current + (["ArrowRight", "ArrowDown"].includes(key.key) ? 1 : -1)));
+				this.#controller.setPage(next);
+				pages[next]?.focus();
+			}
+		}, options);
+		this.#notes.addEventListener("toggle", () => this.#syncNotes(), options);
+		return () => events.abort();
+	}
+	#showTab(tab) {
+		for (const button of this.#root.querySelectorAll("[data-tab]")) {
+			const selected = button.dataset.tab === tab;
+			button.setAttribute("aria-selected", String(selected));
+			button.tabIndex = selected ? 0 : -1;
+		}
+		for (const panel of this.#root.querySelectorAll("[role=\"tabpanel\"]")) panel.hidden = panel.id !== `${tab}-panel`;
+	}
+	#setPane(pane, visible) {
+		(pane === "pages" ? this.#rail : this.#inspector).hidden = !visible;
+		this.#root.querySelector(`[data-chrome="${pane}"]`).setAttribute("aria-pressed", String(visible));
+		this.#syncNotes();
+	}
+	#syncNotes() {
+		this.#root.querySelector(".notes-strip button").setAttribute("aria-expanded", String(!this.#inspector.hidden && this.#notes.open));
+	}
+	#reveal(kind) {
+		this.#setPane("inspector", true);
+		const selector = kind === "notes" ? ".notes" : kind === "edit" ? ".edit-controls" : kind === "layers" ? ".layer-controls" : ".shape-inspector";
+		const panel = this.#root.querySelector(selector);
+		if (panel.hidden) return;
+		panel.open = true;
+		panel.querySelector("summary").focus();
+		panel.scrollIntoView?.({
+			block: "nearest",
+			inline: "nearest"
+		});
+		this.#syncNotes();
+	}
+	render(state, noteCount) {
+		const page = state.document?.pages[state.pageIndex];
+		if (state.document !== this.#document) {
+			this.#document = state.document;
+			const restoreFocus = this.#root.activeElement?.dataset.pageIndex;
+			const fragment = this.#root.ownerDocument.createDocumentFragment();
+			for (const [index, candidate] of (state.document?.pages ?? []).entries()) {
+				const item = this.#root.ownerDocument.createElement("li");
+				const button = this.#root.ownerDocument.createElement("button");
+				button.type = "button";
+				button.className = "page-link";
+				button.dataset.pageIndex = String(index);
+				button.setAttribute("aria-label", `Go to page ${index + 1}: ${candidate.name}`);
+				const number = this.#root.ownerDocument.createElement("span");
+				number.className = "page-number";
+				number.textContent = String(index + 1);
+				const card = this.#root.ownerDocument.createElement("span");
+				card.className = "page-card";
+				const mark = this.#root.ownerDocument.createElement("span");
+				mark.className = "page-mark";
+				mark.textContent = "▤";
+				mark.setAttribute("aria-hidden", "true");
+				const name = this.#root.ownerDocument.createElement("span");
+				name.className = "page-name";
+				name.textContent = candidate.name;
+				const meta = this.#root.ownerDocument.createElement("span");
+				meta.className = "page-meta";
+				meta.textContent = candidate.isBackground ? "Background page" : `${candidate.width} × ${candidate.height} in`;
+				card.append(mark, name, meta);
+				button.append(number, card);
+				item.append(button);
+				fragment.append(item);
+			}
+			this.#pageList.replaceChildren(fragment);
+			if (restoreFocus !== void 0) [...this.#pageList.querySelectorAll("button")].find((button) => button.dataset.pageIndex === restoreFocus)?.focus();
+		}
+		for (const button of this.#pageList.querySelectorAll("button")) {
+			const selected = Number(button.dataset.pageIndex) === state.pageIndex;
+			if (selected) button.setAttribute("aria-current", "page");
+			else button.removeAttribute("aria-current");
+			button.tabIndex = selected ? 0 : -1;
+		}
+		const count = state.document?.pages.length ?? 0;
+		this.#root.querySelector("[data-page-count]").textContent = String(count);
+		this.#root.querySelector(".page-empty").hidden = count > 0;
+		this.#root.querySelector("[data-page-name]").textContent = page?.name ?? "No diagram open";
+		this.#root.querySelector("[data-page-size]").textContent = page ? `${page.width} × ${page.height} in` : "No page";
+		this.#root.querySelector("[data-page-shapes]").textContent = page ? `${page.shapes.length} top-level` : "No shapes";
+		this.#root.querySelector(".selection-hint").hidden = !!state.selectedShape;
+		this.#root.querySelector("[data-chrome=\"previous-page\"]").disabled = !page || state.pageIndex === 0;
+		this.#root.querySelector("[data-chrome=\"next-page\"]").disabled = !page || state.pageIndex >= count - 1;
+		this.#root.querySelector("[data-chrome=\"selection\"]").disabled = !state.selectedShape;
+		this.#root.querySelector("[data-chrome=\"edit\"]").disabled = !page;
+		this.#root.querySelector("[data-chrome=\"layers\"]").disabled = this.#root.querySelector(".layer-controls").hidden;
+		for (const button of this.#root.querySelectorAll("[data-chrome=\"notes\"]")) button.disabled = noteCount === 0;
+		this.#root.querySelector("[data-note-count]").textContent = noteCount ? ` · ${noteCount}` : "";
+		this.#syncNotes();
+	}
+};
+//#endregion
+//#region src/export-svg.ts
+var MAX_SVG_EXPORT_BYTES = 16777216;
+var APPROXIMATION = "Static SVG export is a rendered approximation, not an editable VSDX round-trip or a guarantee of Microsoft Visio fidelity. Fonts are not embedded.";
+var INVALID_XML = "Invalid XML characters were replaced with the Unicode replacement character in the SVG export.";
+var limitError = () => /* @__PURE__ */ new Error("This page exceeds the safe SVG export byte or amplification limit.");
+/**
+* Export one page through the shared renderer, including its resolved backgrounds.
+* Requires a browser DOM at call time, never uploads, downloads or mutates viewer state.
+* Conservative preflight limits can reject a page whose eventual serialization would be smaller.
+*/
+function exportPageSvg(model, pageIndex = 0, options = {}) {
+	const maxBytes = options.maxBytes ?? 16777216;
+	if (!Number.isSafeInteger(maxBytes) || maxBytes < 1 || maxBytes > 16777216) throw new Error("SVG maxBytes must be a positive integer no greater than 16 MiB.");
+	assertViewableDocument(model);
+	if (!Number.isSafeInteger(pageIndex) || pageIndex < 0 || pageIndex >= model.pages.length) throw new Error("The SVG export page index is out of range.");
+	const page = model.pages[pageIndex];
+	const { width, height } = page;
+	estimatePageSvgBytes(model, page, maxBytes);
+	if (typeof document === "undefined" || typeof XMLSerializer === "undefined") throw new Error("SVG export requires a browser DOM and XMLSerializer.");
+	const rendered = renderPage(model, page, { static: true });
+	try {
+		const { svg } = rendered;
+		svg.setAttribute("width", `${width}in`);
+		svg.setAttribute("height", `${height}in`);
+		let replaced = normalizeXmlTree(svg);
+		const notes = compatibilityNotes(model.diagnostics, [APPROXIMATION, ...rendered.warnings]);
+		const pageName = xmlText(page.name);
+		for (const note of notes) {
+			const message = xmlText(note.message);
+			if (message !== note.message) replaced = true;
+			note.message = message;
+		}
+		if (replaced) notes.push({
+			message: INVALID_XML,
+			severity: "warning",
+			count: 1
+		});
+		const description = svgElement("desc");
+		description.textContent = notes.map(compatibilityText).join("\n");
+		svg.insertBefore(description, svg.children[1] ?? null);
+		const metadata = svgElement("metadata");
+		metadata.textContent = JSON.stringify({
+			format: "visio-viewer-static-svg",
+			page: {
+				index: pageIndex,
+				name: pageName,
+				width,
+				height,
+				unit: "in"
+			},
+			diagnostics: notes
+		});
+		svg.append(metadata);
+		assertSerializedBudget(svg, maxBytes);
+		const output = new XMLSerializer().serializeToString(svg);
+		const byteLength = new TextEncoder().encode(output).byteLength;
+		if (byteLength > maxBytes) throw limitError();
+		return {
+			svg: output,
+			byteLength,
+			pageIndex,
+			pageName,
+			width,
+			height,
+			diagnostics: notes
+		};
+	} finally {
+		rendered.dispose();
+	}
+}
+/** @internal Call only after canonical scene validation. Shared conservative allocation preflight. */
+function estimatePageSvgBytes(model, page, maxBytes) {
+	let remaining = maxBytes;
+	const reserve = (bytes) => {
+		remaining -= bytes;
+		if (remaining < 0) throw limitError();
+	};
+	reserve(8192 + page.name.length * 36);
+	for (const note of model.diagnostics) reserve(384 + note.message.length * 36);
+	const images = /* @__PURE__ */ new Map();
+	const stack = [];
+	for (const layer of getVisioPageLayers(model, page.id)) stack.push(...layer.shapes);
+	while (stack.length) {
+		const shape = stack.pop();
+		if (shape.hidden) continue;
+		stack.push(...shape.children);
+		reserve(1024 + (shape.text.plainText || shape.name).length * 6);
+		if (shape.kind === "group" && shape.groupDisplayMode === 0) continue;
+		for (const geometry of shape.geometry) reserve(4096 + geometry.path.length * 6 + shape.style.lineColor.length * 24 + shape.style.fill.length * 6);
+		for (const stop of shape.style.fillGradient?.stops ?? []) reserve(256 + stop.color.length * 6);
+		if (shape.image) {
+			reserve(1536);
+			const image = shape.image;
+			const types = images.get(image.bytes) ?? /* @__PURE__ */ new Set();
+			if (!types.has(image.mimeType)) {
+				reserve(512 + 4 * Math.ceil(image.bytes.byteLength / 3));
+				types.add(image.mimeType);
+				images.set(image.bytes, types);
+			}
+		}
+		if (shape.foreignVector) reserve(inspectForeignVectorResource(shape.foreignVector.vector).svgBytes);
+		if (!shape.text.plainText) continue;
+		const text = shape.text;
+		const runs = text.runs.length ? text.runs : [{
+			text: text.plainText,
+			fontFamily: text.fontFamily,
+			color: text.color
+		}];
+		let characters = 0;
+		for (const run of runs) {
+			characters += run.text.length;
+			reserve(run.text.length * (512 + run.fontFamily.length * 6 + run.color.length * 6));
+		}
+		reserve(Math.min(5e3, characters + (text.paragraphs?.length ?? 1)) * (640 + (text.backgroundColor ? 512 + text.backgroundColor.length * 6 : 0)));
+		for (const paragraph of text.paragraphs ?? []) if (paragraph.bullet) reserve(512 + (paragraph.bullet.text.length + paragraph.bullet.fontFamily.length + text.color.length) * 6);
+	}
+	return maxBytes - remaining;
+}
+function xmlText(value) {
+	return value.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\uFFFE\uFFFF\uD800-\uDFFF]/gu, "�");
+}
+function normalizeXmlTree(root) {
+	let replaced = false;
+	const stack = [root];
+	while (stack.length) {
+		const node = stack.pop();
+		if (node.nodeType === 1) for (const attribute of Array.from(node.attributes)) {
+			const normalized = xmlText(attribute.value);
+			if (normalized !== attribute.value) {
+				replaced = true;
+				attribute.value = normalized;
+			}
+		}
+		else if (node.nodeType === 3) {
+			const normalized = xmlText(node.nodeValue ?? "");
+			if (normalized !== node.nodeValue) {
+				replaced = true;
+				node.nodeValue = normalized;
+			}
+		}
+		stack.push(...node.childNodes);
+	}
+	return replaced;
+}
+/** An upper bound, without allocating a second escaped copy of large paths or data URLs. */
+function assertSerializedBudget(root, maxBytes) {
+	let bytes = 0;
+	const add = (value) => {
+		for (const point of value) {
+			const code = point.codePointAt(0);
+			bytes += /[&<>"'\t\n\r]/u.test(point) ? 6 : code < 128 ? 1 : code < 2048 ? 2 : code < 65536 ? 3 : 4;
+			if (bytes > maxBytes) throw limitError();
+		}
+	};
+	const stack = [root];
+	while (stack.length) {
+		const node = stack.pop();
+		if (node.nodeType === 1) {
+			const element = node;
+			bytes += element.tagName.length * 2 + 5;
+			for (const attribute of element.attributes) {
+				bytes += attribute.name.length + 4;
+				add(attribute.value);
+			}
+		} else if (node.nodeType === 3) add(node.nodeValue ?? "");
+		if (bytes > maxBytes) throw limitError();
+		stack.push(...node.childNodes);
+	}
+}
+//#endregion
+//#region src/snapshot-scene.ts
+/** Copy only named scalar fields, never arbitrary host properties or their getters. */
+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 invalid();
+		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 invalid = () => /* @__PURE__ */ new Error("The scene exceeds safe snapshot copy limits.");
+/**
+* @internal Copy a canonically validated scene without retaining any renderer-used mutable input.
+* The caller validates the result before use. Independent allocation caps also bound a host that
+* changes its arrays while fields are read. Shared raster buffers are copied once per invocation.
+* Inspector metadata, connectors, layers and unknown host properties are not used by static SVG.
+*/
+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 invalid();
+		counts.set(key, total);
+	};
+	const list = (source, key, maximum, copy) => {
+		if (!Array.isArray(source)) throw invalid();
+		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 > 8388608) throw invalid();
+		let bytes = resources.get(original);
+		if (!bytes) {
+			take("raster bytes", original.byteLength, 67108864);
+			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 invalid();
+			return [];
+		}
+		return list(source, "shapes", 25e3, (shape) => {
+			if (seen.has(shape)) throw invalid();
+			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: []
+		}))
+	};
+}
+//#endregion
+//#region src/print-snapshot.ts
+/** Application guardrails, not printer capabilities or Microsoft Visio limits. */
+var PRINT_SNAPSHOT_LIMITS = Object.freeze({
+	maxPages: 32,
+	maxTotalBytes: 33554432,
+	maxPageBytes: MAX_SVG_EXPORT_BYTES,
+	maxShapeInstances: 1e5,
+	maxGeometryInstances: 1e5,
+	maxPathCharacters: 16e6,
+	maxTextCharacters: 1e6,
+	maxTextRuns: 1e5,
+	maxImageBytes: 67108864,
+	maxUniqueImagePixels: 64e6,
+	maxImageInstancePixels: 256e6,
+	maxVectorNodes: FOREIGN_VECTOR_SCENE_LIMITS.maxNodes,
+	maxVectorCommands: FOREIGN_VECTOR_SCENE_LIMITS.maxCommands,
+	maxVectorOperands: FOREIGN_VECTOR_SCENE_LIMITS.maxOperands,
+	maxPageAxisCssPixels: 4096,
+	maxPageAreaCssPixels: 16e6,
+	maxTotalAreaCssPixels: 64e6,
+	maxValidationShapeVisits: 1e6,
+	maxValidationWork: 268435456
+});
+var LIMITATIONS = Object.freeze([
+	"This snapshot reproduces supported saved drawing display appearance, independent of viewport zoom, pan, selection, search highlighting and temporary viewer filters. It is not a guarantee of Microsoft Visio fidelity.",
+	"Saved print visibility, including per-layer Print and NonPrinting, is not applied. This snapshot preserves saved display visibility and does not reveal hidden content for printing.",
+	"Saved printer settings are unsupported. Drawing dimensions are not printer paper, margins, orientation, tiling or print scale. This snapshot only prepares isolated drawing artifacts and does not print."
+]);
+var exceeded = (name) => /* @__PURE__ */ new Error(`Print snapshot exceeds the safe ${name} limit. Select fewer or smaller pages.`);
+function within(value, limit, name) {
+	if (!Number.isFinite(value) || value > limit) throw exceeded(name);
+}
+function copyLimits(input) {
+	if (input !== void 0 && (!input || typeof input !== "object" || Array.isArray(input))) throw new Error("Print snapshot limits must be an object.");
+	const limits = { ...PRINT_SNAPSHOT_LIMITS };
+	for (const key of Object.keys(input ?? {})) {
+		if (!Object.hasOwn(limits, key)) throw new Error(`Unknown print snapshot limit: ${key}.`);
+		const name = key;
+		const value = input[name];
+		if (!Number.isSafeInteger(value) || value < 1 || value > PRINT_SNAPSHOT_LIMITS[name]) throw new Error(`Print snapshot ${name} must be a positive integer no greater than ${PRINT_SNAPSHOT_LIMITS[name]}.`);
+		limits[name] = value;
+	}
+	return Object.freeze(limits);
+}
+/**
+* Synchronously prepare bounded, immutable page artifacts through the shared SVG renderer.
+* Requires its DOM/serializer, but never mounts nodes, downloads, fetches, opens frames or prints.
+* Canonical scene/raster validation is repeated on every call. No source object is frozen.
+* Conservative budgets include hidden content and can reject otherwise exportable individual pages.
+*/
+function createPrintSnapshot(model, options) {
+	if (!options || typeof options !== "object" || !Array.isArray(options.pageIndices)) throw new Error("Print snapshot requires an explicit pageIndices array.");
+	for (const key of Object.keys(options)) if (key !== "pageIndices" && key !== "limits") throw new Error(`Unknown print snapshot option: ${key}.`);
+	const limits = copyLimits(options.limits);
+	if (!options.pageIndices.length) throw new Error("Print snapshot page selection must not be empty.");
+	within(options.pageIndices.length, limits.maxPages, "selected page count");
+	const pageIndices = Object.freeze([...options.pageIndices]);
+	const seen = /* @__PURE__ */ new Set();
+	for (const index of pageIndices) {
+		if (!Number.isSafeInteger(index) || index < 0 || !Array.isArray(model.pages) || index >= model.pages.length) throw new Error("Print snapshot page index is out of range.");
+		if (seen.has(index)) throw new Error("Print snapshot page selection contains duplicate indices.");
+		seen.add(index);
+	}
+	assertViewableDocument(model);
+	const validation = validationCost(model);
+	const passes = 3 + 2 * pageIndices.length;
+	const vectorPasses = 5 + 6 * pageIndices.length;
+	const usage = {
+		estimatedSvgBytes: 0,
+		svgBytes: 0,
+		shapeInstances: 0,
+		geometryInstances: 0,
+		pathCharacters: 0,
+		textCharacters: 0,
+		textRuns: 0,
+		imageBytes: 0,
+		uniqueImagePixels: 0,
+		imageInstancePixels: 0,
+		vectorNodes: 0,
+		vectorCommands: 0,
+		vectorOperands: 0,
+		totalAreaCssPixels: 0,
+		validationShapeVisits: validation.shapes * passes,
+		validationWork: validation.work * passes + validation.vectorWork * vectorPasses
+	};
+	within(usage.validationShapeVisits, limits.maxValidationShapeVisits, "whole-document validation shape visits");
+	within(usage.validationWork, limits.maxValidationWork, "whole-document validation work");
+	model = copySnapshotScene(model);
+	assertViewableDocument(model);
+	const detached = validationCost(model);
+	usage.validationShapeVisits = Math.max(validation.shapes, detached.shapes) * passes;
+	usage.validationWork = Math.max(validation.work, detached.work) * passes + Math.max(validation.vectorWork, detached.vectorWork) * vectorPasses;
+	within(usage.validationShapeVisits, limits.maxValidationShapeVisits, "whole-document validation shape visits");
+	within(usage.validationWork, limits.maxValidationWork, "whole-document validation work");
+	const add = (key, value, limit) => {
+		usage[key] += value;
+		within(usage[key], limit, key);
+	};
+	for (const index of pageIndices) {
+		const page = model.pages[index];
+		const width = page.width * 96, height = page.height * 96;
+		within(width, limits.maxPageAxisCssPixels, "drawing width in CSS pixels");
+		within(height, limits.maxPageAxisCssPixels, "drawing height in CSS pixels");
+		within(width * height, limits.maxPageAreaCssPixels, "drawing area in CSS pixels");
+		add("totalAreaCssPixels", width * height, limits.maxTotalAreaCssPixels);
+		const resources = /* @__PURE__ */ new Set();
+		for (const layer of getVisioPageLayers(model, page.id)) {
+			const stack = [...layer.shapes];
+			while (stack.length) {
+				const shape = stack.pop();
+				add("shapeInstances", 1, limits.maxShapeInstances);
+				add("geometryInstances", shape.geometry.length, limits.maxGeometryInstances);
+				for (const geometry of shape.geometry) add("pathCharacters", geometry.path.length, limits.maxPathCharacters);
+				add("textCharacters", shape.text.plainText.length, limits.maxTextCharacters);
+				add("textRuns", shape.text.runs.length, limits.maxTextRuns);
+				for (const run of shape.text.runs) add("textCharacters", run.text.length, limits.maxTextCharacters);
+				if (shape.foreignVector) {
+					const vector = inspectForeignVectorResource(shape.foreignVector.vector);
+					add("vectorNodes", vector.nodes, limits.maxVectorNodes);
+					add("vectorCommands", vector.commands, limits.maxVectorCommands);
+					add("vectorOperands", vector.operands, limits.maxVectorOperands);
+				}
+				if (shape.image) {
+					const { bytes, pixelWidth, pixelHeight } = shape.image;
+					add("imageInstancePixels", pixelWidth * pixelHeight, limits.maxImageInstancePixels);
+					if (!resources.has(bytes)) {
+						resources.add(bytes);
+						add("imageBytes", bytes.byteLength, limits.maxImageBytes);
+						add("uniqueImagePixels", pixelWidth * pixelHeight, limits.maxUniqueImagePixels);
+					}
+				}
+				stack.push(...shape.children);
+			}
+		}
+		add("estimatedSvgBytes", estimatePageSvgBytes(model, page, limits.maxPageBytes), limits.maxTotalBytes);
+	}
+	const pages = [];
+	for (const pageIndex of pageIndices) {
+		const pageId = model.pages[pageIndex].id;
+		const result = exportPageSvg(model, pageIndex, { maxBytes: limits.maxPageBytes });
+		add("svgBytes", result.byteLength, limits.maxTotalBytes);
+		pages.push(Object.freeze({
+			pageIndex,
+			pageId,
+			pageName: result.pageName,
+			drawingSize: Object.freeze({
+				width: result.width,
+				height: result.height,
+				unit: "in"
+			}),
+			svg: result.svg,
+			byteLength: result.byteLength,
+			diagnostics: Object.freeze(result.diagnostics.map((note) => Object.freeze({ ...note })))
+		}));
+	}
+	return Object.freeze({
+		appearance: "saved-display",
+		pageIndices,
+		pages: Object.freeze(pages),
+		byteLength: usage.svgBytes,
+		limits,
+		usage: Object.freeze(usage),
+		limitations: LIMITATIONS
+	});
+}
+/** Cost accounting only. Format interpretation and safety checks remain canonical. */
+function validationCost(model) {
+	let shapes = 0, work = model.pages.length, vectorWork = 0;
+	const images = /* @__PURE__ */ new Set();
+	const strings = (...values) => {
+		for (const value of values) work += 1 + (value?.length ?? 0);
+	};
+	for (const note of model.diagnostics) strings(note.code, note.message);
+	for (const page of model.pages) {
+		strings(page.id, page.name, page.backgroundPageId);
+		for (const layer of page.layers ?? []) strings(layer.id, layer.name);
+		const stack = [...page.shapes];
+		while (stack.length) {
+			const shape = stack.pop();
+			shapes++;
+			work += 64;
+			strings(shape.id, shape.name, shape.style.fill, shape.style.lineColor, shape.text.plainText, shape.text.fontFamily, shape.text.color, shape.text.backgroundColor);
+			for (const geometry of shape.geometry) strings(geometry.path);
+			for (const stop of shape.style.fillGradient?.stops ?? []) {
+				work += 3;
+				strings(stop.color);
+			}
+			for (const run of shape.text.runs) {
+				work += 8;
+				strings(run.text, run.fontFamily, run.color);
+			}
+			for (const paragraph of shape.text.paragraphs ?? []) {
+				work += 16;
+				if (paragraph.bullet) strings(paragraph.bullet.text, paragraph.bullet.fontFamily);
+			}
+			for (const rows of [shape.shapeData ?? [], shape.hyperlinks ?? []]) for (const row of rows) {
+				const count = (record) => {
+					for (const value of Object.values(record)) work += 1 + (typeof value === "string" ? value.length : 0);
+				};
+				count(row);
+				if ("target" in row) count(row.target);
+			}
+			if (shape.image && !images.has(shape.image.bytes)) {
+				images.add(shape.image.bytes);
+				work += shape.image.bytes.byteLength;
+			}
+			if (shape.foreignVector) vectorWork += inspectForeignVectorResource(shape.foreignVector.vector).validationWork;
+			stack.push(...shape.children);
+		}
+	}
+	return {
+		shapes,
+		work,
+		vectorWork
+	};
+}
+//#endregion
+//#region src/viewer-element.ts
+var BaseElement = typeof HTMLElement === "undefined" ? class {} : HTMLElement;
+var VisioViewerElement = class extends BaseElement {
+	controller = new ViewerController(createWorkerParser());
+	#root;
+	#disposeInputs;
+	#viewport;
+	#pageSelect;
+	#zoomLabel;
+	#status;
+	#diagnostics;
+	#toolbar;
+	#chrome;
+	#search;
+	#edit;
+	#layers;
+	#renderedLayerOverrides;
+	#revealedSearchResult;
+	#notes;
+	#notesPanel;
+	#inspector;
+	#inspectedShape;
+	#renderedSelection = null;
+	#unsubscribe;
+	#eventUnsubscribe;
+	#document = null;
+	#renderedPage = -1;
+	#disposed = false;
+	#suspended = false;
+	#renderWarnings = [];
+	#disposeRenderer = () => {};
+	#fontEvents;
+	#fontsChanged = () => {
+		if (this.#disposed) return;
+		this.#document = null;
+		this.#renderedPage = -1;
+		this.#render(this.controller.state);
+	};
+	constructor() {
+		super();
+		this.#root = this.attachShadow({ mode: "open" });
+		this.#root.innerHTML = `<style>${viewerStyles}</style>${viewerChromeTemplate}`;
+		this.#viewport = this.#root.querySelector(".viewport");
+		this.#pageSelect = this.#root.querySelector("select");
+		this.#zoomLabel = this.#root.querySelector("output");
+		this.#status = this.#root.querySelector("[data-status]");
+		this.#diagnostics = this.#root.querySelector("[data-diagnostics]");
+		this.#toolbar = this.#root.querySelector(".toolbar");
+		this.#search = searchControls(this.#root);
+		this.#edit = new ViewerEditControls(this.#root, this.controller);
+		this.#layers = this.#root.querySelector(".layer-controls");
+		this.#notes = this.#root.querySelector(".notes ul");
+		this.#notesPanel = this.#root.querySelector(".notes");
+		this.#inspector = this.#root.querySelector(".shape-inspector");
+		this.#chrome = new ViewerChrome(this.#root, this.controller);
+		this.#disposeInputs = this.#wireInputs();
+		this.#unsubscribe = this.controller.subscribe((state) => this.#render(state));
+		this.#eventUnsubscribe = this.controller.onEvent((name, detail) => {
+			this.dispatchEvent(new CustomEvent(name, {
+				detail,
+				bubbles: true,
+				composed: true
+			}));
+		});
+	}
+	get document() {
+		return this.controller.state.document;
+	}
+	set document(value) {
+		this.controller.setDocument(value);
+	}
+	get pageIndex() {
+		return this.controller.state.pageIndex;
+	}
+	set pageIndex(value) {
+		this.controller.setPage(value);
+	}
+	get zoom() {
+		return this.controller.state.zoom;
+	}
+	set zoom(value) {
+		this.controller.setZoom(value);
+	}
+	get showToolbar() {
+		return !this.#toolbar.hidden;
+	}
+	set showToolbar(value) {
+		this.#assertAlive();
+		this.#toolbar.hidden = !value;
+		this.#root.querySelector(".zoom-controls").hidden = !value;
+	}
+	get renderWarnings() {
+		return this.#renderWarnings;
+	}
+	async load(source) {
+		this.#assertAlive();
+		if (source instanceof Blob) await this.controller.loadSource(() => {
+			if (source.size > 33554432) throw new Error("This viewer accepts files up to 32 MiB.");
+			return source.arrayBuffer();
+		});
+		else await this.controller.load(source);
+	}
+	applyEdits(edits) {
+		this.#assertAlive();
+		return this.controller.applyEdits(edits);
+	}
+	replacePlainText(pageId, shapeId, text) {
+		this.#assertAlive();
+		return this.controller.replacePlainText(pageId, shapeId, text);
+	}
+	undo() {
+		this.#assertAlive();
+		return this.controller.undo();
+	}
+	redo() {
+		this.#assertAlive();
+		return this.controller.redo();
+	}
+	cancelEdit() {
+		this.#assertAlive();
+		this.#edit.reset(false);
+	}
+	exportVsdx() {
+		this.#assertAlive();
+		return this.controller.exportVsdx();
+	}
+	fit() {
+		this.#assertAlive();
+		const page = this.document?.pages[this.pageIndex];
+		if (!page) return;
+		const style = this.ownerDocument.defaultView?.getComputedStyle(this.#viewport);
+		const padding = (value) => Number.parseFloat(value ?? "") || 0;
+		const width = Math.max(1, this.#viewport.clientWidth - padding(style?.paddingLeft) - padding(style?.paddingRight));
+		const height = Math.max(1, this.#viewport.clientHeight - padding(style?.paddingTop) - padding(style?.paddingBottom));
+		this.zoom = Math.min(1, width / (page.width * 96), height / (page.height * 96));
+	}
+	setLayerVisibility(pageId, layerId, visible) {
+		this.#assertAlive();
+		this.controller.setLayerVisibility(pageId, layerId, visible);
+	}
+	resetLayerVisibility(pageId) {
+		this.#assertAlive();
+		this.controller.resetLayerVisibility(pageId);
+	}
+	/** Return a portable saved-display current-page snapshot without changing selection or downloading a file. */
+	exportSvg(options) {
+		this.#assertAlive();
+		const { document, pageIndex } = this.controller.state;
+		if (!document) throw new Error("Open a document before exporting SVG.");
+		return exportPageSvg(document, pageIndex, options);
+	}
+	/** Prepare only the captured current drawing with saved display visibility. No frame, download, print dialog or state change. */
+	createPrintSnapshot(options) {
+		this.#assertAlive();
+		if (options !== void 0 && (!options || typeof options !== "object" || Array.isArray(options) || "pageIndices" in options)) throw new Error("Current-page print snapshot options may only contain limits.");
+		const { document, pageIndex } = this.controller.state;
+		const generation = this.controller.documentGeneration;
+		if (!document) throw new Error("Open a document before preparing a print snapshot.");
+		const page = document.pages[pageIndex];
+		const result = createPrintSnapshot(document, {
+			...options,
+			pageIndices: [pageIndex]
+		});
+		this.#assertAlive();
+		if (generation !== this.controller.documentGeneration || document.pages[pageIndex] !== page) throw new Error("The document changed while preparing the print snapshot.");
+		return result;
+	}
+	destroy() {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		this.#disposeInputs();
+		this.#fontEvents?.removeEventListener("loadingdone", this.#fontsChanged);
+		this.#fontEvents = void 0;
+		this.#disposeRenderer();
+		this.#unsubscribe();
+		this.#eventUnsubscribe();
+		this.controller.destroy();
+		this.#revealedSearchResult = void 0;
+		this.#renderedSelection = null;
+		this.#root.replaceChildren();
+	}
+	connectedCallback() {
+		if (this.#disposed) return;
+		if (this.#suspended) this.#disposeInputs = this.#wireInputs();
+		this.#suspended = false;
+		this.#fontEvents = this.ownerDocument.fonts;
+		this.#fontEvents?.addEventListener("loadingdone", this.#fontsChanged);
+		this.#render(this.controller.state);
+	}
+	disconnectedCallback() {
+		if (!this.#disposed) {
+			this.#suspended = true;
+			this.#disposeInputs();
+			this.#fontEvents?.removeEventListener("loadingdone", this.#fontsChanged);
+			this.#fontEvents = void 0;
+			this.controller.cancelLoad();
+			this.controller.cancelEdit();
+			this.#disposeRenderer();
+			this.#document = null;
+			this.#renderedPage = -1;
+		}
+	}
+	#wireInputs() {
+		const disposeChrome = this.#chrome.wire();
+		const disposeEdit = this.#edit.wire();
+		const disposeLayers = wireLayerControls(this.#layers, this.controller);
+		const disposeInputs = wireViewerInputs({
+			viewport: this.#viewport,
+			commandRoot: this.#root,
+			pageSelect: this.#pageSelect,
+			searchInput: this.#search.input
+		}, this.controller, () => this.fit());
+		return () => {
+			disposeChrome();
+			disposeInputs();
+			disposeLayers();
+			disposeEdit();
+		};
+	}
+	#assertAlive() {
+		if (this.#disposed) throw new Error("The viewer has been destroyed.");
+	}
+	#render(state) {
+		if (this.#suspended) return;
+		const page = state.document?.pages[state.pageIndex];
+		const changed = this.#document !== state.document || this.#renderedPage !== state.pageIndex || this.#renderedLayerOverrides !== state.layerVisibilityOverrides;
+		if (changed) {
+			this.#disposeRenderer();
+			this.#disposeRenderer = () => {};
+			this.#document = state.document;
+			this.#renderedPage = state.pageIndex;
+			this.#renderedLayerOverrides = state.layerVisibilityOverrides;
+			this.#pageSelect.replaceChildren();
+			for (const [index, candidate] of (state.document?.pages ?? []).entries()) {
+				const option = document.createElement("option");
+				option.value = String(index);
+				option.textContent = candidate.name + (candidate.isBackground ? " (background)" : "");
+				this.#pageSelect.append(option);
+			}
+			this.#pageSelect.value = String(state.pageIndex);
+			this.#renderWarnings = [];
+			if (state.document && page) {
+				const result = renderPage(state.document, page, { layerVisibilityOverrides: state.layerVisibilityOverrides });
+				this.#renderWarnings = result.warnings;
+				this.#disposeRenderer = result.dispose;
+				this.#viewport.replaceChildren(result.svg);
+			} else {
+				const empty = document.createElement("div");
+				empty.className = "empty";
+				const heading = document.createElement("strong");
+				heading.textContent = "Open a Visio drawing";
+				empty.append(heading, "Open a .vsdx file to start. Files stay in this browser.");
+				this.#viewport.replaceChildren(empty);
+			}
+			const notes = compatibilityNotes(state.document?.diagnostics ?? [], this.#renderWarnings);
+			this.#notes.replaceChildren(...notes.map((note) => {
+				const item = document.createElement("li");
+				item.textContent = compatibilityText(note);
+				return item;
+			}));
+			this.#notesPanel.hidden = !notes.length;
+		}
+		const svg = this.#viewport.querySelector("svg");
+		if (svg && page) {
+			svg.style.width = `${page.width * 96 * state.zoom}px`;
+			svg.style.height = `${page.height * 96 * state.zoom}px`;
+		}
+		const searchResult = state.search.results[state.search.activeIndex];
+		const selection = state.selectedShape;
+		if (changed || this.#renderedSelection?.id !== selection?.id || this.#renderedSelection?.pageId !== selection?.pageId || this.#renderedSelection?.name !== selection?.name || searchResult && searchResult !== this.#revealedSearchResult) {
+			for (const shape of this.#viewport.querySelectorAll("[data-shape-id]")) {
+				const selected = !!state.selectedShape && shape.dataset.shapeId === state.selectedShape.id && (!state.selectedShape.pageId || shape.dataset.pageId === state.selectedShape.pageId);
+				shape.dataset.selected = String(selected);
+				if (selected && searchResult && searchResult !== this.#revealedSearchResult && shape.dataset.shapeId === searchResult.shapeId && shape.dataset.pageId === searchResult.pageId) {
+					shape.scrollIntoView?.({
+						block: "nearest",
+						inline: "nearest"
+					});
+					this.#revealedSearchResult = searchResult;
+				}
+				if (state.selectedShape) shape.setAttribute("tabindex", selected ? "0" : "-1");
+				if (shape.getAttribute("role") === "button") shape.setAttribute("aria-pressed", String(selected));
+			}
+			const inspected = selectedShape(state.document, state.selectedShape, state.pageIndex);
+			if (inspected !== this.#inspectedShape) {
+				this.#inspectedShape = inspected;
+				this.#inspector.hidden = !inspected;
+				if (inspected) this.#inspector.open = true;
+				this.#inspector.querySelector("div").replaceChildren(...inspected ? [shapeDetails(inspected)] : []);
+			}
+			this.#renderedSelection = selection ? { ...selection } : null;
+		}
+		if (!searchResult) this.#revealedSearchResult = void 0;
+		this.#zoomLabel.value = `${Math.round(state.zoom * 100)}%`;
+		this.#pageSelect.disabled = !page;
+		for (const button of this.#root.querySelectorAll("[data-action]")) button.disabled = !page;
+		renderSearchControls(this.#search, state);
+		this.#edit.render(state);
+		if (changed) renderLayerControls(this.#layers, state);
+		else this.#layers.querySelector("[data-layer-reset=\"all\"]").disabled = state.layerVisibilityOverrides.length === 0;
+		this.#chrome.render(state, this.#notes.children.length);
+		this.#viewport.setAttribute("aria-busy", String(state.loading || state.edit.busy));
+		this.#status.textContent = state.loading ? "Opening diagram…" : state.error?.message ?? (page ? `${page.name} · ${page.shapes.length} top-level shapes` : "No diagram open");
+		const warnings = (state.document?.diagnostics.length ?? 0) + this.#renderWarnings.length;
+		this.#diagnostics.textContent = warnings ? `${this.#notes.children.length} compatibility notes` : "Local-only viewing";
+	}
+};
+function registerVisioViewer() {
+	if (typeof customElements === "undefined") throw new Error("Register the Visio viewer in a browser.");
+	if (!customElements.get("visio-viewer")) customElements.define("visio-viewer", VisioViewerElement);
+}
+//#endregion
+//#region src/binding.ts
+/** One client-only lifecycle adapter; framework wrappers forward to this implementation. */
+function mountViewer(container, initial = {}) {
+	registerVisioViewer();
+	const element = document.createElement("visio-viewer");
+	let destroyed = false;
+	let updateRevision = 0;
+	let callbacks = {};
+	const listeners = eventKeys.map((name) => {
+		const listener = (event) => {
+			const callback = callbacks[name];
+			callback?.(event.detail);
+		};
+		element.addEventListener(name, listener);
+		return {
+			name,
+			listener
+		};
+	});
+	function assertAlive() {
+		if (destroyed) throw new Error("The viewer has been destroyed.");
+	}
+	function update(options) {
+		assertAlive();
+		const revision = ++updateRevision;
+		if ("events" in options) callbacks = options.events ?? {};
+		for (const key of propertyKeys) {
+			if (destroyed || revision !== updateRevision) break;
+			if (!(key in options)) continue;
+			if (key === "document" && options.document !== void 0) {
+				if (element.document !== options.document) element.document = options.document;
+			} else if (key === "pageIndex" && options.pageIndex !== void 0) element.pageIndex = options.pageIndex;
+			else if (key === "zoom" && options.zoom !== void 0) element.zoom = options.zoom;
+			else if (key === "showToolbar" && options.showToolbar !== void 0) element.showToolbar = options.showToolbar;
+		}
+	}
+	update(initial);
+	container.append(element);
+	return {
+		element,
+		controller: element.controller,
+		update,
+		async load(source) {
+			assertAlive();
+			await element.load(source);
+		},
+		async applyEdits(edits) {
+			assertAlive();
+			await element.applyEdits(edits);
+		},
+		async replacePlainText(pageId, shapeId, text) {
+			assertAlive();
+			await element.replacePlainText(pageId, shapeId, text);
+		},
+		async undo() {
+			assertAlive();
+			await element.undo();
+		},
+		async redo() {
+			assertAlive();
+			await element.redo();
+		},
+		cancelEdit() {
+			assertAlive();
+			element.cancelEdit();
+		},
+		exportVsdx() {
+			assertAlive();
+			return element.exportVsdx();
+		},
+		fit() {
+			assertAlive();
+			element.fit();
+		},
+		setLayerVisibility(pageId, layerId, visible) {
+			assertAlive();
+			element.setLayerVisibility(pageId, layerId, visible);
+		},
+		resetLayerVisibility(pageId) {
+			assertAlive();
+			element.resetLayerVisibility(pageId);
+		},
+		exportSvg(options) {
+			assertAlive();
+			return element.exportSvg(options);
+		},
+		createPrintSnapshot(options) {
+			assertAlive();
+			return element.createPrintSnapshot(options);
+		},
+		destroy() {
+			if (destroyed) return;
+			destroyed = true;
+			callbacks = {};
+			for (const { name, listener } of listeners) element.removeEventListener(name, listener);
+			element.destroy();
+			element.remove();
+		}
+	};
+}
+//#endregion
+//#region packages/bindings/src/common.ts
+/** One mapping for every property and event, shared by every framework adapter. */
+function viewerOptions(props) {
+	const result = { events: props.events ?? {} };
+	for (const key of propertyKeys) {
+		const value = props[key];
+		if (value !== void 0) Object.assign(result, { [key]: value });
+	}
+	return result;
+}
+/**
+* Native props are snapshots, while the browser binding accepts explicit patches. Forward only
+* changed properties so a callback/class update cannot undo an imperative load or user zoom.
+*/
+function mountFrameworkViewer(container, initial) {
+	const binding = mountViewer(container, initial);
+	let previous = { ...initial };
+	let destroyed = false;
+	let updateRevision = 0;
+	const activePatches = /* @__PURE__ */ new Set();
+	return {
+		...binding,
+		update(next) {
+			if (destroyed) throw new Error("The viewer has been destroyed.");
+			const revision = ++updateRevision;
+			const snapshot = { ...next };
+			const patch = { events: snapshot.events ?? {} };
+			for (const key of propertyKeys) {
+				const touchedByOlderCall = [...activePatches].some((active) => key in active);
+				if (snapshot[key] !== void 0 && (snapshot[key] !== previous[key] || touchedByOlderCall)) Object.assign(patch, { [key]: snapshot[key] });
+			}
+			activePatches.add(patch);
+			try {
+				binding.update(patch);
+			} finally {
+				activePatches.delete(patch);
+			}
+			if (!destroyed && revision === updateRevision) previous = snapshot;
+		},
+		destroy() {
+			if (destroyed) return;
+			destroyed = true;
+			previous = {};
+			binding.destroy();
+		}
+	};
+}
+/** Lazy imperative methods reject both before mount and after unmount. */
+function viewerHandle(current) {
+	const requireViewer = () => {
+		const binding = current();
+		if (!binding) throw new Error("The viewer is not mounted.");
+		return binding;
+	};
+	return {
+		get element() {
+			return requireViewer().element;
+		},
+		get controller() {
+			return requireViewer().controller;
+		},
+		async load(source) {
+			await requireViewer().load(source);
+		},
+		async applyEdits(edits) {
+			await requireViewer().applyEdits(edits);
+		},
+		async replacePlainText(pageId, shapeId, text) {
+			await requireViewer().replacePlainText(pageId, shapeId, text);
+		},
+		async undo() {
+			await requireViewer().undo();
+		},
+		async redo() {
+			await requireViewer().redo();
+		},
+		cancelEdit() {
+			requireViewer().cancelEdit();
+		},
+		exportVsdx() {
+			return requireViewer().exportVsdx();
+		},
+		fit() {
+			requireViewer().fit();
+		},
+		setLayerVisibility(pageId, layerId, visible) {
+			requireViewer().setLayerVisibility(pageId, layerId, visible);
+		},
+		resetLayerVisibility(pageId) {
+			requireViewer().resetLayerVisibility(pageId);
+		},
+		exportSvg(options) {
+			return requireViewer().exportSvg(options);
+		},
+		createPrintSnapshot(options) {
+			return requireViewer().createPrintSnapshot(options);
+		}
+	};
+}
+//#endregion
+//#region packages/bindings/src/react.ts
+/** React owns only the host and lifecycle; the shared element owns all viewer behavior. */
+var VisioViewer = forwardRef(function VisioViewer(props, ref) {
+	const host = useRef(null);
+	const binding = useRef(void 0);
+	useEffect(() => {
+		const mounted = mountFrameworkViewer(host.current, viewerOptions(props));
+		binding.current = mounted;
+		return () => {
+			binding.current = void 0;
+			mounted.destroy();
+		};
+	}, []);
+	useEffect(() => {
+		binding.current?.update(viewerOptions(props));
+	});
+	useImperativeHandle(ref, () => viewerHandle(() => binding.current), []);
+	return createElement("div", {
+		ref: host,
+		className: props.className,
+		style: props.style,
+		"aria-label": props["aria-label"]
+	});
+});
+//#endregion
+export { MAX_SVG_EXPORT_BYTES, PRINT_SNAPSHOT_LIMITS, TEXT_SEARCH_LIMITS, VIEWER_LAYER_LIMITS, ViewerController, VisioViewer, VisioViewerElement, compatibilityNotes, compatibilityText, createPrintSnapshot, createWorkerParser, eventKeys, exportPageSvg, mountViewer, propertyKeys, registerVisioViewer, renderPage };