@ai-markdown/core 3.3.1 → 3.4.1

package/dist/components/index.js

@@ -1,3 +1,4 @@
+import { StreamingLanguageDetector } from "@ai-markdown/code-language-detector";
 function extractCode(node) {
 	if (node?.tagName !== "pre" || node.children.length !== 1 || Object.keys(node.properties).length) return null;
 	const child = node.children[0];
@@ -43,19 +44,26 @@ function text(node) {
 	if (node.tagName === "img" || node.tagName === "cross-chunk-image") return String(node.properties.alt ?? "");
 	return node.children.map(text).join("");
 }
+var ExportRefused = class extends Error {
+	reason;
+	constructor(reason) {
+		super(reason);
+		this.reason = reason;
+	}
+};
 function projectTable(node) {
 	try {
-		if (node?.tagName !== "table") throw new Error("Table source is unavailable");
+		if (node?.tagName !== "table") throw new ExportRefused("unavailable");
 		const rows = [];
 		const walk = (parent) => {
 			for (const child of parent.children) {
 				if (child.type === "text" && !child.value.trim()) continue;
-				if (child.type !== "element") throw new Error("Unsupported table content");
+				if (child.type !== "element") throw new ExportRefused("unsupportedContent");
 				if (child.tagName === "tr") {
 					const cells = [];
 					for (const cell of child.children) {
 						if (cell.type === "text" && !cell.value.trim()) continue;
-						if (cell.type !== "element" || !["th", "td"].includes(cell.tagName) || Number(cell.properties.colSpan ?? 1) !== 1 || Number(cell.properties.rowSpan ?? 1) !== 1) throw new Error("Only tables without merged cells can be exported");
+						if (cell.type !== "element" || !["th", "td"].includes(cell.tagName) || Number(cell.properties.colSpan ?? 1) !== 1 || Number(cell.properties.rowSpan ?? 1) !== 1) throw new ExportRefused("mergedCells");
 						cells.push(text(cell));
 					}
 					rows.push(cells);
@@ -64,14 +72,14 @@ function projectTable(node) {
 					"tbody",
 					"tfoot"
 				].includes(child.tagName) && parent === node) walk(child);
-				else throw new Error("Unsupported table structure");
+				else throw new ExportRefused("unsupportedStructure");
 			}
 		};
 		walk(node);
-		if (!rows.length || !rows[0].length || rows.some((r) => r.length !== rows[0].length)) throw new Error("Only rectangular tables can be exported");
+		if (!rows.length || !rows[0].length || rows.some((r) => r.length !== rows[0].length)) throw new ExportRefused("notRectangular");
 		return { rows };
 	} catch (error) {
-		return { reason: error instanceof Error ? error.message : "Table cannot be exported" };
+		return { reason: error instanceof ExportRefused ? error.reason : "unavailable" };
 	}
 }
 const formulaPrefix = /^[\s\u0000-\u001f]*[=+@-]/;
@@ -81,6 +89,57 @@ function serializeTable(rows, delimiter = ",") {
 		return /["\r\n\t,]/.test(value) ? `"${value.replaceAll("\"", "\"\"")}"` : value;
 	}).join(delimiter)).join("\r\n");
 }
+function codeBody(code) {
+	return code.endsWith("\n") ? code.slice(0, -1) : code;
+}
+function startsWithText(text, prefix) {
+	return text.length >= prefix.length && text.slice(0, prefix.length) === prefix;
+}
+function extendsCode(next, previous) {
+	return startsWithText(next, codeBody(previous));
+}
+function createCodeLanguageTracker(onSettle) {
+	const detector = new StreamingLanguageDetector();
+	let followed;
+	let settled = null;
+	let timer;
+	const cancel = () => {
+		if (timer !== void 0) clearTimeout(timer);
+		timer = void 0;
+	};
+	const judge = (from, text, streaming) => (streaming && settled !== text ? from.update(text) : from.finalize(text)).language;
+	return {
+		read(code, streaming) {
+			if (followed !== void 0 && extendsCode(code, followed)) return detector.current.language;
+			return judge(new StreamingLanguageDetector(), codeBody(code), streaming);
+		},
+		observe(code, streaming) {
+			cancel();
+			const text = codeBody(code);
+			const starting = followed === void 0 || !extendsCode(code, followed);
+			if (starting) detector.reset();
+			const before = detector.current.language;
+			followed = code;
+			const after = judge(detector, text, streaming);
+			if (streaming && settled !== text) timer = setTimeout(() => {
+				timer = void 0;
+				settled = text;
+				detector.finalize(text);
+				onSettle();
+			}, 300);
+			return !starting && before !== after;
+		},
+		dispose: cancel
+	};
+}
+function nextCodeFrame(previous, code, language) {
+	if (previous?.code === code && previous.language === language) return previous;
+	return {
+		code,
+		language,
+		generation: previous && language === previous.language && extendsCode(code, previous.code) ? previous.generation : {}
+	};
+}
 function createCodeFrame(initial, publish) {
 	let shown = initial;
 	let latest = initial;
@@ -98,7 +157,7 @@ function createCodeFrame(initial, publish) {
 	};
 	return {
 		update(next, streaming, interval) {
-			const replaced = next.language !== latest.language || !next.code.startsWith(latest.code);
+			const replaced = next.generation !== latest.generation;
 			latest = next;
 			if (delay !== interval) cancel();
 			delay = interval;
@@ -160,16 +219,17 @@ function createJsonCompletenessScanner() {
 	let invalid = false;
 	let last = "";
 	return (text) => {
+		const body = codeBody(text);
 		let from = previous.length;
-		if (!text.startsWith(previous)) {
+		if (!startsWithText(body, previous)) {
 			from = 0;
 			depth = 0;
 			quoted = escaped = invalid = false;
 			last = "";
 		}
-		previous = text;
-		for (let i = from; i < text.length; i++) {
-			const c = text[i];
+		previous = body;
+		for (let i = from; i < body.length; i++) {
+			const c = body[i];
 			if (!/\s/.test(c)) last = c;
 			if (quoted) {
 				if (escaped) escaped = false;
@@ -188,6 +248,89 @@ function createJsonCompletenessScanner() {
 function jsonLooksComplete(text) {
 	return createJsonCompletenessScanner()(text);
 }
+function createCodeBlockSession(onChange) {
+	let committed;
+	let shown;
+	let frames;
+	let token;
+	let committing = false;
+	const tracker = createCodeLanguageTracker(() => onChange());
+	const scanJson = createJsonCompletenessScanner();
+	let formatted;
+	const generationOf = (input) => {
+		if (!committed) return 0;
+		return input.identity === committed.identity && input.language === committed.language && extendsCode(input.code, committed.code) ? committed.generation : committed.generation + 1;
+	};
+	const languageOf = (input) => input.language || (input.autoDetect ? tracker.read(input.code, input.streaming) ?? "" : "");
+	const pretty = (source, nested) => {
+		if (formatted?.source !== source || formatted.nested !== nested) formatted = {
+			source,
+			nested,
+			text: prettyPrintJson(source, nested)
+		};
+		return formatted.text;
+	};
+	return {
+		read(input) {
+			const generation = generationOf(input);
+			const language = languageOf(input);
+			const displayed = !shown || !input.streaming || input.highlightIntervalMs === 0 || shown.generation !== generation || shown.language !== language ? input.code : shown.code;
+			return {
+				text: input.formatJson && displayed && language === "json" && (!input.streaming || scanJson(displayed)) ? pretty(displayed, input.expandNestedJson) : displayed,
+				language,
+				generation
+			};
+		},
+		commit(input) {
+			const generation = generationOf(input);
+			const moved = input.autoDetect && !input.language ? tracker.observe(input.code, input.streaming) : (tracker.dispose(), false);
+			const language = languageOf(input);
+			committed = {
+				code: input.code,
+				language: input.language,
+				identity: input.identity,
+				generation
+			};
+			const key = `${generation}:${language}`;
+			if (token?.key !== key) token = {
+				key,
+				value: {}
+			};
+			const frame = {
+				code: input.code,
+				language,
+				generation: token.value
+			};
+			committing = true;
+			try {
+				if (!frames) {
+					shown = {
+						code: input.code,
+						language,
+						generation
+					};
+					frames = createCodeFrame(frame, (next) => {
+						shown = {
+							code: next.code,
+							language: next.language,
+							generation: committed.generation
+						};
+						if (!committing) onChange();
+					});
+				}
+				frames.update(frame, input.streaming, input.highlightIntervalMs);
+				if (shown.code === input.code && shown.language === language) shown.generation = generation;
+			} finally {
+				committing = false;
+			}
+			if (moved) onChange();
+		},
+		dispose() {
+			frames?.dispose();
+			tracker.dispose();
+		}
+	};
+}
 function createRenderQueue() {
 	const pending = /* @__PURE__ */ new Map();
 	let running = false;
@@ -229,9 +372,6 @@ function createRenderQueue() {
 const mermaidRenderQueue = createRenderQueue();
 const SAFE_SECURITY_LEVELS = /* @__PURE__ */ new Set(["strict", "sandbox"]);
 let ownedThemes = /* @__PURE__ */ new WeakMap();
-const resetMermaidInitializationForTests = () => {
-	ownedThemes = /* @__PURE__ */ new WeakMap();
-};
 const readSiteConfig = (mermaid) => {
 	const api = mermaid.mermaidAPI;
 	return api?.getSiteConfig?.() ?? api?.getConfig?.() ?? {};
@@ -269,94 +409,265 @@ const ensureMermaidInitialized = (mermaid, isDark) => {
 	}
 	mermaid.initialize(next);
 };
-let nextId = 0;
+function diagramErrorText(error, labels) {
+	if (error.reason === "tooLarge") return labels.tooLarge(error.length, error.limit);
+	return error.message || labels.renderFailed;
+}
+const ERROR_MESSAGE_MAX_CHARS = 500;
+const LOAD_RETRIES = 3;
+const LOAD_RETRY_MS = 1500;
+function engineMessage(error) {
+	const text = (error instanceof Error ? error.message : typeof error === "string" ? error : "").replace(/\r\n?/g, "\n").trim();
+	return text.length > ERROR_MESSAGE_MAX_CHARS ? `${text.slice(0, ERROR_MESSAGE_MAX_CHARS)}…` : text;
+}
+var DiagramFailure = class {
+	view;
+	constructor(view) {
+		this.view = view;
+	}
+};
+const diagramId = () => `mermaid-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
 function createDiagramController(load, publish) {
 	const owner = {};
+	let request;
+	let current;
+	let shown;
+	let frames;
+	let updating = false;
+	let view = { kind: "source" };
+	let loadFailed = false;
+	let previousStreaming = false;
+	let needsCorrective = false;
+	let lastSuccess;
+	let loadFailures = 0;
+	let nonce = 0;
+	let ran;
 	let epoch = 0;
-	let previous;
-	let svg = "";
-	let bind;
-	let timer;
+	let retryTimer;
+	const sameError = (a, b) => a.reason === "tooLarge" ? b.reason === "tooLarge" && a.length === b.length && a.limit === b.limit : b.reason === a.reason && a.message === b.message;
+	const emit = () => publish({
+		view,
+		loadFailed
+	});
+	const show = (next) => {
+		if (next.kind === "source" && view.kind === "source") return;
+		if (next.kind === "error" && view.kind === "error" && sameError(next, view)) return;
+		view = next;
+		emit();
+	};
 	const cancel = () => {
 		epoch++;
-		if (timer !== void 0) clearTimeout(timer);
-		timer = void 0;
 		mermaidRenderQueue.cancel(owner);
+		if (retryTimer !== void 0) clearTimeout(retryTimer);
+		retryTimer = void 0;
 	};
-	return {
-		update(request) {
-			const replaced = !previous || previous.resetKey !== request.resetKey || previous.dark !== request.dark || !request.code.startsWith(previous.code);
-			const pending = timer !== void 0;
-			epoch++;
-			mermaidRenderQueue.cancel(owner);
-			if (replaced) {
-				svg = "";
-				bind = void 0;
-				if (timer !== void 0) clearTimeout(timer);
-				timer = void 0;
-			}
-			previous = request;
-			if (!request.active) {
-				cancel();
-				return;
+	const attempt = async (code, dark, streaming, generation) => {
+		const stale = () => generation !== epoch;
+		let engine;
+		try {
+			engine = await load();
+		} catch {
+			if (stale()) return;
+			if (loadFailures < LOAD_RETRIES) {
+				loadFailures += 1;
+				retryTimer = setTimeout(() => {
+					retryTimer = void 0;
+					nonce++;
+					run();
+				}, LOAD_RETRY_MS);
+			} else if (!loadFailed) {
+				loadFailed = true;
+				emit();
 			}
-			publish({
-				status: "loading",
+			return;
+		}
+		loadFailures = 0;
+		let reason = "render";
+		try {
+			if (stale()) return;
+			ensureMermaidInitialized(engine, dark);
+			const maxTextSize = getMermaidMaxTextSize(engine);
+			if (code.length > maxTextSize) throw new DiagramFailure({
+				kind: "error",
+				reason: "tooLarge",
+				length: code.length,
+				limit: maxTextSize
+			});
+			reason = "parse";
+			if (!await engine.parse(code)) throw new DiagramFailure({
+				kind: "error",
+				reason: "parse",
+				message: ""
+			});
+			reason = "render";
+			if (stale()) return;
+			const { svg, bindFunctions, diagramType } = await engine.render(diagramId(), code);
+			if (stale()) return;
+			needsCorrective = false;
+			lastSuccess = {
+				code,
+				dark
+			};
+			loadFailed = false;
+			show({
+				kind: "diagram",
 				svg,
-				bind
+				chartType: diagramType ?? "",
+				bind: bindFunctions
 			});
-			const attempt = () => {
-				timer = void 0;
-				const current = previous;
-				const generation = epoch;
-				const valid = () => generation === epoch;
-				let phase = "load";
-				load().then((engine) => {
-					phase = "render";
-					if (!valid()) return;
-					return mermaidRenderQueue.enqueue(owner, async () => {
-						if (!valid()) return;
-						ensureMermaidInitialized(engine, current.dark);
-						if (current.code.length > getMermaidMaxTextSize(engine)) throw new Error("Diagram exceeds Mermaid’s maximum text size");
-						const parsed = await engine.parse(current.code, { suppressErrors: true });
-						if (!valid()) return;
-						if (parsed === false) throw new Error("Diagram syntax is incomplete or invalid");
-						const result = await engine.render(`aimd-diagram-${++nextId}`, current.code);
-						if (!valid()) return;
-						svg = result.svg;
-						bind = result.bindFunctions;
-						publish({
-							status: "ready",
-							svg,
-							bind
-						});
-					});
-				}).catch((error) => {
-					if (valid()) publish({
-						status: current.streaming && phase === "render" ? "loading" : "error",
-						svg,
-						bind,
-						error: (phase === "load" ? "Diagram engine could not load: " : "") + (error instanceof Error ? error.message : String(error)).slice(0, 500)
-					});
-				});
+		} catch (error) {
+			if (stale()) return;
+			if (streaming) return;
+			const failure = error instanceof DiagramFailure ? error.view : {
+				kind: "error",
+				reason,
+				message: engineMessage(error)
 			};
-			if (!request.streaming || request.interval <= 0) {
-				if (timer !== void 0) clearTimeout(timer);
-				attempt();
-			} else if (!pending || replaced) timer = setTimeout(attempt, request.interval);
+			if (needsCorrective) {
+				needsCorrective = false;
+				show(failure);
+				return;
+			}
+			if (view.kind === "diagram") return;
+			show(failure);
+		}
+	};
+	function run() {
+		if (!request || !current || !shown) return;
+		const { dark, active, streaming, interval } = request;
+		const code = !streaming || interval === 0 || current.generation !== shown.generation ? request.code : shown.code;
+		if (ran && ran.code === code && ran.dark === dark && ran.active === active && ran.streaming === streaming && ran.nonce === nonce) return;
+		ran = {
+			code,
+			dark,
+			active,
+			streaming,
+			nonce
+		};
+		cancel();
+		if (streaming && !previousStreaming) {
+			needsCorrective = false;
+			lastSuccess = void 0;
+			loadFailures = 0;
+			if (view.kind !== "source" || loadFailed) {
+				loadFailed = false;
+				view = { kind: "source" };
+				emit();
+			}
+		} else if (!streaming && previousStreaming) needsCorrective = true;
+		previousStreaming = streaming;
+		if (!code || !active) return;
+		if (lastSuccess?.code === code && lastSuccess.dark === dark) {
+			needsCorrective = false;
+			return;
+		}
+		const generation = epoch;
+		mermaidRenderQueue.enqueue(owner, () => attempt(code, dark, streaming, generation));
+	}
+	return {
+		update(next) {
+			request = next;
+			updating = true;
+			try {
+				if (!frames || !current) {
+					current = shown = nextCodeFrame(void 0, next.code, "");
+					frames = createCodeFrame(current, (frame) => {
+						shown = frame;
+						if (!updating) run();
+					});
+				} else current = nextCodeFrame(current, next.code, "");
+				frames.update(current, next.streaming, next.interval);
+			} finally {
+				updating = false;
+			}
+			run();
 		},
-		dispose: cancel
+		retry() {
+			loadFailures = 0;
+			if (loadFailed) {
+				loadFailed = false;
+				emit();
+			}
+			nonce++;
+			run();
+		},
+		dispose() {
+			cancel();
+			frames?.dispose();
+			ran = void 0;
+		}
 	};
 }
+function resolveLabels(defaults, option) {
+	const overrides = typeof option === "function" ? option() : option;
+	if (!overrides) return defaults;
+	const labels = { ...defaults };
+	for (const key of Object.keys(overrides)) {
+		const value = overrides[key];
+		if (value !== void 0) labels[key] = value;
+	}
+	return labels;
+}
+const defaultCodeBlockLabels = Object.freeze({
+	actions: "Code block actions",
+	plainText: "text",
+	copy: "Copy code",
+	copied: "Copied",
+	copyFailed: "Copy failed",
+	showSource: "Show source",
+	showPreview: "Show preview",
+	expand: "Expand",
+	collapse: "Collapse",
+	previewFailed: "Preview failed. Source is available below."
+});
+const defaultDiagramLabels = Object.freeze({
+	waiting: "Waiting for diagram…",
+	rendering: "Rendering diagram…",
+	loadFailed: "Diagram engine could not load.",
+	retry: "Retry diagram",
+	renderFailed: "Mermaid could not render this diagram.",
+	tooLarge: (length, limit) => `Diagram source is ${length} characters, above mermaid's maxTextSize of ${limit}.`
+});
+const defaultImageLabels = Object.freeze({
+	close: "Close preview",
+	prev: "Previous image",
+	next: "Next image",
+	rotateLeft: "Rotate left",
+	rotateRight: "Rotate right",
+	zoomIn: "Zoom in",
+	zoomOut: "Zoom out",
+	flipX: "Flip horizontally",
+	flipY: "Flip vertically",
+	loading: "Loading image…",
+	loadFailed: "Image could not be loaded.",
+	open: (alt) => `Preview image${alt ? `: ${alt}` : ""}`,
+	preview: "Image preview",
+	actions: "Image preview actions"
+});
+const defaultTableLabels = Object.freeze({
+	actions: "Table actions",
+	copy: "Copy table",
+	download: "Download CSV",
+	copied: "Table copied",
+	copyFailed: "Copy failed",
+	scrollRegion: "Scrollable table",
+	mergedCells: "Only tables without merged cells can be exported",
+	notRectangular: "Only rectangular tables can be exported",
+	unsupportedStructure: "Unsupported table structure",
+	unsupportedContent: "Unsupported table content",
+	unavailable: "Table source is unavailable"
+});
 const locks = /* @__PURE__ */ new WeakMap();
-function lockImagePreviewScroll(target) {
+function lockImagePreviewScroll(target, scrollbarWidth = 0) {
 	let lock = locks.get(target);
 	if (!lock) {
 		lock = {
 			count: 0,
-			overflow: target.style.overflow
+			overflow: target.style.overflow,
+			paddingRight: target.style.paddingRight
 		};
 		locks.set(target, lock);
+		if (scrollbarWidth > 0) target.style.paddingRight = lock.paddingRight ? `calc(${lock.paddingRight} + ${scrollbarWidth}px)` : `${scrollbarWidth}px`;
 	}
 	lock.count++;
 	target.style.overflow = "hidden";
@@ -366,10 +677,454 @@ function lockImagePreviewScroll(target) {
 		released = true;
 		if (--lock.count === 0) {
 			if (target.style.overflow === "hidden") target.style.overflow = lock.overflow;
+			target.style.paddingRight = lock.paddingRight;
 			locks.delete(target);
 		}
 	};
 }
+const initialImageTransform = () => ({
+	x: 0,
+	y: 0,
+	rotate: 0,
+	scale: 1,
+	flipX: false,
+	flipY: false
+});
+function imageTransformStyle(transform) {
+	const { x, y, scale, rotate, flipX, flipY } = transform;
+	return `translate3d(${x}px, ${y}px, 0) scale3d(${flipX ? "-" : ""}${scale}, ${flipY ? "-" : ""}${scale}, 1) rotate(${rotate}deg)`;
+}
+const DEFAULT_SCALE_LIMITS = {
+	min: 1,
+	max: 50
+};
+function zoomImage(transform, ratio, geometry, centerX = geometry.viewportWidth / 2, centerY = geometry.viewportHeight / 2, touch = false, limits = DEFAULT_SCALE_LIMITS) {
+	if (!Number.isFinite(ratio) || ratio <= 0) return transform;
+	const floor = touch ? .01 : limits.min;
+	const scale = Math.min(limits.max, Math.max(floor, transform.scale * ratio));
+	const difference = scale / transform.scale - 1;
+	let x = transform.x - difference * (centerX - transform.x - geometry.left - geometry.width / 2);
+	let y = transform.y - difference * (centerY - transform.y - geometry.top - geometry.height / 2);
+	if (ratio < 1 && scale === 1 && geometry.width <= geometry.viewportWidth && geometry.height <= geometry.viewportHeight) x = y = 0;
+	return {
+		...transform,
+		x,
+		y,
+		scale
+	};
+}
+function imageWheelRatio(delta, mode = 0, pinch = false, step = .5) {
+	if (!Number.isFinite(delta) || delta === 0) return 1;
+	if (pinch) return Math.min(1 + step, Math.max(1 / (1 + step), Math.exp(-delta / 100)));
+	const pixels = mode === 1 ? delta * 100 / 3 : mode === 2 ? delta * 100 : delta;
+	const ratio = 1 + Math.min(Math.abs(pixels / 100), 1) * step;
+	return pixels > 0 ? 1 / ratio : ratio;
+}
+function reboundImage(transform, geometry, bounds, minScale = 1) {
+	if (transform.scale < minScale) return {
+		...transform,
+		x: 0,
+		y: 0,
+		scale: minScale
+	};
+	const rotated = transform.rotate % 180 !== 0;
+	const width = (rotated ? geometry.height : geometry.width) * transform.scale;
+	const height = (rotated ? geometry.width : geometry.height) * transform.scale;
+	if (width <= geometry.viewportWidth && height <= geometry.viewportHeight) return {
+		...transform,
+		x: 0,
+		y: 0
+	};
+	const fix = (position, start, size, viewport) => {
+		const offset = (size - viewport) / 2;
+		if (size > viewport) {
+			if (start > 0) return offset;
+			if (start < 0 && start + size < viewport) return -offset;
+		} else if (start < 0 || start + size > viewport) return start < 0 ? offset : -offset;
+		return position;
+	};
+	return {
+		...transform,
+		x: fix(transform.x, bounds.left, width, geometry.viewportWidth),
+		y: fix(transform.y, bounds.top, height, geometry.viewportHeight)
+	};
+}
+function imagePinchCenter(oldA, oldB, a, b) {
+	const distanceA = Math.hypot(a.x - oldA.x, a.y - oldA.y), distanceB = Math.hypot(b.x - oldB.x, b.y - oldB.y);
+	const ratio = distanceA + distanceB ? distanceA / (distanceA + distanceB) : 0;
+	return {
+		x: oldA.x + ratio * (oldB.x - oldA.x),
+		y: oldA.y + ratio * (oldB.y - oldA.y)
+	};
+}
+const CLOSE_MS = 300;
+const positive = (value, fallback) => typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+const closedState = Object.freeze({
+	phase: "closed",
+	items: Object.freeze([]),
+	current: -1,
+	item: void 0,
+	transform: initialImageTransform(),
+	status: "loading",
+	moving: false,
+	movable: true,
+	origin: void 0,
+	canPrevious: false,
+	canNext: false,
+	canZoomIn: false,
+	canZoomOut: false
+});
+function createImagePreviewController(host, publish, options = {}) {
+	const limits = {
+		min: positive(options.minScale, 1),
+		max: 0
+	};
+	limits.max = Math.max(limits.min, positive(options.maxScale, 50));
+	const baseScale = Math.min(limits.max, Math.max(limits.min, 1));
+	const scaleStep = positive(options.scaleStep, .5);
+	const movable = options.movable ?? true;
+	const wheelZoom = options.wheel ?? true;
+	let phase = "closed";
+	let items = [];
+	let selected;
+	let current = -1;
+	let transform = {
+		...initialImageTransform(),
+		scale: baseScale
+	};
+	let status = "loading";
+	let moving = false;
+	let origin;
+	let unsubscribe;
+	let cancelPublish;
+	let cancelOpening;
+	let closeTimer;
+	const pointers = /* @__PURE__ */ new Map();
+	let grip;
+	let displaced = false;
+	const snapshot = () => {
+		if (phase === "closed") return closedState;
+		const ready = status === "ready";
+		return {
+			phase,
+			items,
+			current,
+			item: items[current],
+			transform,
+			status,
+			moving,
+			movable,
+			origin,
+			canPrevious: current > 0,
+			canNext: current < items.length - 1,
+			canZoomIn: ready && transform.scale < limits.max,
+			canZoomOut: ready && transform.scale > limits.min
+		};
+	};
+	let reported;
+	const flush = () => {
+		publish(snapshot());
+		const action = reported;
+		reported = void 0;
+		if (action) options.onTransform?.({
+			transform,
+			action
+		});
+	};
+	const emit = () => {
+		cancelPublish?.();
+		cancelPublish = void 0;
+		flush();
+	};
+	const emitNextFrame = () => {
+		cancelPublish ??= host.frame(() => {
+			cancelPublish = void 0;
+			flush();
+		});
+	};
+	const apply = (next, action) => {
+		if (next.x === transform.x && next.y === transform.y && next.scale === transform.scale && next.rotate === transform.rotate && next.flipX === transform.flipX && next.flipY === transform.flipY) return;
+		transform = next;
+		reported = action;
+	};
+	const endGesture = () => {
+		pointers.clear();
+		grip = void 0;
+		displaced = false;
+		moving = false;
+	};
+	const startImage = () => {
+		transform = {
+			...initialImageTransform(),
+			scale: baseScale
+		};
+		reported = void 0;
+		status = "loading";
+		endGesture();
+	};
+	const zoom = (action, ratio, x, y, touch = false) => {
+		const box = host.geometry();
+		if (box && status === "ready") apply(zoomImage(transform, ratio, box, x, y, touch, limits), action);
+	};
+	const rebound = () => {
+		if (transform.scale < limits.min) {
+			apply({
+				...transform,
+				x: 0,
+				y: 0,
+				scale: limits.min
+			}, "rebound");
+			return;
+		}
+		const box = host.geometry();
+		if (!box) return;
+		const turned = transform.rotate % 180 !== 0;
+		const width = (turned ? box.height : box.width) * transform.scale;
+		const height = (turned ? box.width : box.height) * transform.scale;
+		apply(reboundImage(transform, box, {
+			left: box.left + box.width / 2 + transform.x - width / 2,
+			top: box.top + box.height / 2 + transform.y - height / 2
+		}, limits.min), "rebound");
+	};
+	const anchorOf = (id) => {
+		const point = host.anchor?.(id);
+		return point && Number.isFinite(point.x) && Number.isFinite(point.y) ? {
+			x: point.x,
+			y: point.y
+		} : void 0;
+	};
+	const finishClosing = () => {
+		closeTimer = void 0;
+		phase = "closed";
+		items = [];
+		selected = void 0;
+		origin = void 0;
+		current = -1;
+		reported = void 0;
+		emit();
+		options.afterOpenChange?.(false);
+	};
+	const close = () => {
+		if (phase === "closed" || phase === "closing") return;
+		cancelOpening?.();
+		cancelOpening = void 0;
+		unsubscribe?.();
+		unsubscribe = void 0;
+		endGesture();
+		reported = void 0;
+		origin = selected ? anchorOf(selected) : void 0;
+		phase = "closing";
+		const info = {
+			current,
+			item: items[current]
+		};
+		const duration = typeof options.closeDuration === "function" ? options.closeDuration() : options.closeDuration ?? CLOSE_MS;
+		if (duration > 0) {
+			emit();
+			closeTimer = setTimeout(finishClosing, duration);
+			options.onOpenChange?.(false, info);
+		} else try {
+			options.onOpenChange?.(false, info);
+		} finally {
+			if (phase === "closing") finishClosing();
+		}
+	};
+	const go = (delta) => {
+		const target = current + delta;
+		if (phase === "closed" || phase === "closing" || target < 0 || target >= items.length || target === current) return;
+		const previous = current;
+		const { x, y, scale, rotate, flipX, flipY } = transform;
+		const transformed = x !== 0 || y !== 0 || scale !== baseScale || rotate !== 0 || flipX || flipY;
+		current = target;
+		selected = items[target].id;
+		startImage();
+		if (transformed) reported = delta < 0 ? "prev" : "next";
+		emit();
+		options.onChange?.(current, previous);
+	};
+	const follow = (gallery) => {
+		const next = gallery.items();
+		const index = next.findIndex((item) => item.id === selected);
+		if (index < 0) return close();
+		if (next[index].src !== items[current]?.src) startImage();
+		items = next;
+		current = index;
+		emit();
+	};
+	return {
+		state: snapshot,
+		open(gallery, id) {
+			const list = gallery.items();
+			const index = list.findIndex((item) => item.id === id);
+			if (index < 0) return false;
+			if (closeTimer !== void 0) clearTimeout(closeTimer);
+			closeTimer = void 0;
+			unsubscribe?.();
+			cancelOpening?.();
+			items = list;
+			current = index;
+			selected = id;
+			origin = anchorOf(id);
+			startImage();
+			unsubscribe = gallery.subscribe(() => follow(gallery));
+			if (phase === "open") {
+				emit();
+				return true;
+			}
+			cancelOpening = void 0;
+			const starting = phase !== "opening";
+			phase = "opening";
+			emit();
+			cancelOpening = host.frame(() => {
+				const measured = selected ? anchorOf(selected) : void 0;
+				if (measured?.x !== origin?.x || measured?.y !== origin?.y) {
+					origin = measured;
+					emit();
+				}
+				cancelOpening = host.frame(() => {
+					cancelOpening = void 0;
+					phase = "open";
+					emit();
+					options.afterOpenChange?.(true);
+				});
+			});
+			if (starting) options.onOpenChange?.(true, {
+				current,
+				item: items[current]
+			});
+			return true;
+		},
+		close,
+		go,
+		action(name) {
+			if (phase === "closed" || phase === "closing") return;
+			if (name === "close") return close();
+			if (name === "prev") return go(-1);
+			if (name === "next") return go(1);
+			if (status !== "ready") return;
+			if (name === "zoomIn") zoom(name, 1 + scaleStep);
+			else if (name === "zoomOut") zoom(name, 1 / (1 + scaleStep));
+			else if (name === "rotateLeft") apply({
+				...transform,
+				rotate: transform.rotate - 90
+			}, name);
+			else if (name === "rotateRight") apply({
+				...transform,
+				rotate: transform.rotate + 90
+			}, name);
+			else if (name === "flipX") apply({
+				...transform,
+				flipX: !transform.flipX
+			}, name);
+			else if (name === "flipY") apply({
+				...transform,
+				flipY: !transform.flipY
+			}, name);
+			emit();
+		},
+		loaded() {
+			if (phase === "closed" || status === "ready") return;
+			status = "ready";
+			emit();
+		},
+		failed() {
+			if (phase === "closed" || status === "error") return;
+			status = "error";
+			endGesture();
+			emit();
+		},
+		pointerDown(pointer) {
+			if (!movable || phase !== "open" && phase !== "opening" || status !== "ready") return false;
+			if (pointer.button !== void 0 && pointer.button !== 0) return false;
+			if (pointers.size >= 2 && !pointers.has(pointer.id)) return false;
+			pointers.set(pointer.id, {
+				x: pointer.x,
+				y: pointer.y
+			});
+			grip = pointers.size === 1 ? {
+				x: pointer.x - transform.x,
+				y: pointer.y - transform.y
+			} : void 0;
+			moving = true;
+			emit();
+			return true;
+		},
+		pointerMove(pointer) {
+			const previous = pointers.get(pointer.id);
+			if (!previous || previous.x === pointer.x && previous.y === pointer.y) return;
+			const before = [...pointers.values()];
+			pointers.set(pointer.id, {
+				x: pointer.x,
+				y: pointer.y
+			});
+			if (pointers.size === 2) {
+				const [a, b] = [...pointers.values()];
+				const span = Math.hypot(before[0].x - before[1].x, before[0].y - before[1].y);
+				const center = imagePinchCenter(before[0], before[1], a, b);
+				if (span > 0) zoom("pinch", Math.hypot(a.x - b.x, a.y - b.y) / span, center.x, center.y, true);
+			} else if (grip) apply({
+				...transform,
+				x: pointer.x - grip.x,
+				y: pointer.y - grip.y
+			}, "move");
+			displaced = true;
+			emitNextFrame();
+		},
+		pointerUp(id) {
+			if (!pointers.delete(id)) return;
+			const [remaining] = pointers.values();
+			if (remaining) {
+				grip = {
+					x: remaining.x - transform.x,
+					y: remaining.y - transform.y
+				};
+				return;
+			}
+			const settle = displaced;
+			endGesture();
+			if (settle) rebound();
+			emit();
+		},
+		wheel(input) {
+			if (!wheelZoom || phase !== "open" || status !== "ready" || !input.deltaY) return false;
+			zoom("wheel", imageWheelRatio(input.deltaY, input.mode, input.pinch, scaleStep), input.x, input.y);
+			emitNextFrame();
+			return true;
+		},
+		doubleClick(x, y) {
+			if (phase !== "open" || status !== "ready") return;
+			if (transform.scale !== baseScale) apply({
+				...transform,
+				x: 0,
+				y: 0,
+				scale: baseScale
+			}, "doubleClick");
+			else zoom("doubleClick", 1 + scaleStep, x, y);
+			emit();
+		},
+		key(key) {
+			if (phase !== "open" && phase !== "opening" || items.length < 2) return false;
+			if (key !== "ArrowLeft" && key !== "ArrowRight") return false;
+			go(key === "ArrowLeft" ? -1 : 1);
+			return true;
+		},
+		dispose() {
+			if (closeTimer !== void 0) clearTimeout(closeTimer);
+			closeTimer = void 0;
+			cancelPublish?.();
+			cancelOpening?.();
+			unsubscribe?.();
+			cancelPublish = cancelOpening = unsubscribe = void 0;
+			endGesture();
+			phase = "closed";
+			items = [];
+			selected = void 0;
+			origin = void 0;
+			current = -1;
+			reported = void 0;
+		}
+	};
+}
 const imageIconPaths = {
 	rotateLeft: ["M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8", "M3 3v5h5"],
 	rotateRight: ["M21 12a9 9 0 1 1-9-9c2.52 0 4.93 1 6.74 2.74L21 8", "M21 3v5h-5"],
@@ -416,16 +1171,20 @@ const imageIconPaths = {
 		"M11 9a2 2 0 1 1-4 0 2 2 0 0 1 4 0"
 	]
 };
-const imageGroupSelector = "[data-aimd-image-scope], .aim-typography-root, .aimd-vue, .mantine-Typography-root";
 const galleries = /* @__PURE__ */ new WeakMap();
 function getImageGallery(scope) {
 	const existing = galleries.get(scope);
 	if (existing) return existing;
 	const entries = /* @__PURE__ */ new Map();
 	const listeners = /* @__PURE__ */ new Set();
-	const notify = () => listeners.forEach((listener) => listener());
+	let sorted;
+	const notify = () => {
+		sorted = void 0;
+		listeners.forEach((listener) => listener());
+	};
 	const gallery = {
-		items: () => [...entries.values()].sort((a, b) => a.precedes(b.id) ? -1 : b.precedes(a.id) ? 1 : 0),
+		items: () => sorted ??= [...entries.values()].sort((a, b) => a.precedes(b.id) ? -1 : b.precedes(a.id) ? 1 : 0),
+		size: () => entries.size,
 		subscribe(listener) {
 			listeners.add(listener);
 			return () => {
@@ -445,84 +1204,17 @@ function getImageGallery(scope) {
 	galleries.set(scope, gallery);
 	return gallery;
 }
-const imageActionLabels = {
-	close: "Close preview",
-	prev: "Previous image",
-	next: "Next image",
-	rotateLeft: "Rotate left",
-	rotateRight: "Rotate right",
-	zoomIn: "Zoom in",
-	zoomOut: "Zoom out",
-	flipX: "Flip horizontally",
-	flipY: "Flip vertically"
-};
-const initialImageTransform = () => ({
-	x: 0,
-	y: 0,
-	rotate: 0,
-	scale: 1,
-	flipX: false,
-	flipY: false
-});
-function imageTransformStyle(transform) {
-	const { x, y, scale, rotate, flipX, flipY } = transform;
-	return `translate3d(${x}px, ${y}px, 0) scale3d(${flipX ? "-" : ""}${scale}, ${flipY ? "-" : ""}${scale}, 1) rotate(${rotate}deg)`;
-}
-function zoomImage(transform, ratio, geometry, centerX = geometry.viewportWidth / 2, centerY = geometry.viewportHeight / 2, touch = false) {
-	if (!Number.isFinite(ratio) || ratio <= 0) return transform;
-	const scale = Math.min(50, touch ? Math.max(.01, transform.scale * ratio) : Math.max(1, transform.scale * ratio));
-	const difference = scale / transform.scale - 1;
-	let x = transform.x - difference * (centerX - transform.x - geometry.left - geometry.width / 2);
-	let y = transform.y - difference * (centerY - transform.y - geometry.top - geometry.height / 2);
-	if (ratio < 1 && scale === 1 && geometry.width <= geometry.viewportWidth && geometry.height <= geometry.viewportHeight) x = y = 0;
-	return {
-		...transform,
-		x,
-		y,
-		scale
-	};
-}
-function imageWheelRatio(delta) {
-	const ratio = 1 + Math.min(Math.abs(delta / 100), 1) * .5;
-	return delta > 0 ? 1 / ratio : ratio;
-}
-function reboundImage(transform, geometry, bounds) {
-	if (transform.scale < 1) return {
-		...transform,
-		x: 0,
-		y: 0,
-		scale: 1
-	};
-	const rotated = transform.rotate % 180 !== 0;
-	const width = (rotated ? geometry.height : geometry.width) * transform.scale;
-	const height = (rotated ? geometry.width : geometry.height) * transform.scale;
-	if (width <= geometry.viewportWidth && height <= geometry.viewportHeight) return {
-		...transform,
-		x: 0,
-		y: 0
-	};
-	const fix = (position, start, size, viewport) => {
-		const offset = (size - viewport) / 2;
-		if (size > viewport) {
-			if (start > 0) return offset;
-			if (start < 0 && start + size < viewport) return -offset;
-		} else if (start < 0 || start + size > viewport) return start < 0 ? offset : -offset;
-		return position;
-	};
-	return {
-		...transform,
-		x: fix(transform.x, bounds.left, width, geometry.viewportWidth),
-		y: fix(transform.y, bounds.top, height, geometry.viewportHeight)
-	};
-}
-function imagePinchCenter(oldA, oldB, a, b) {
-	const distanceA = Math.hypot(a.x - oldA.x, a.y - oldA.y), distanceB = Math.hypot(b.x - oldB.x, b.y - oldB.y);
-	const ratio = distanceA + distanceB ? distanceA / (distanceA + distanceB) : 0;
-	return {
-		x: oldA.x + ratio * (oldB.x - oldA.x),
-		y: oldA.y + ratio * (oldB.y - oldA.y)
-	};
-}
-export { MERMAID_DEFAULT_MAX_TEXT_SIZE, createCodeFrame, createDiagramController, createJsonCompletenessScanner, createRenderQueue, ensureMermaidInitialized, extractCode, getImageGallery, getMermaidMaxTextSize, imageActionLabels, imageGroupSelector, imageIconPaths, imagePinchCenter, imageTransformStyle, imageWheelRatio, initialImageTransform, jsonLooksComplete, lockImagePreviewScroll, mermaidRenderQueue, normalizeRenderers, prettyPrintJson, projectTable, reboundImage, resetMermaidInitializationForTests, serializeTable, zoomImage };
+const imageActionNames = Object.freeze([
+	"close",
+	"prev",
+	"next",
+	"rotateLeft",
+	"rotateRight",
+	"zoomIn",
+	"zoomOut",
+	"flipX",
+	"flipY"
+]);
+export { createCodeBlockSession, createCodeFrame, createCodeLanguageTracker, createDiagramController, createImagePreviewController, createJsonCompletenessScanner, defaultCodeBlockLabels, defaultDiagramLabels, defaultImageLabels, defaultTableLabels, diagramErrorText, ensureMermaidInitialized, extendsCode, extractCode, getImageGallery, getMermaidMaxTextSize, imageActionNames, imageIconPaths, imagePinchCenter, imageTransformStyle, imageWheelRatio, initialImageTransform, jsonLooksComplete, lockImagePreviewScroll, mermaidRenderQueue, nextCodeFrame, normalizeRenderers, prettyPrintJson, projectTable, reboundImage, resolveLabels, serializeTable, zoomImage };
 
 //# sourceMappingURL=index.js.map