@feugene/granularity 0.12.0 → 0.16.0

package/dist/components/GrImageViewer/chunks/GrImageViewer-BeCnE8XQ.js

@@ -0,0 +1,1103 @@
+import { t as x_default } from "../../../chunks/x-2KXnqxiD.js";
+import { n as useGranularityTranslations } from "../../../chunks/granularityI18n-BC5zsj_d.js";
+import { t as GrIcon_default } from "../../GrIcon/chunks/GrIcon-BvA2ZGXP.js";
+import { t as minus_default } from "../../../chunks/minus-oxdbHF33.js";
+import { t as useModalOverlay } from "../../../chunks/useModalOverlay-DCM4d3yA.js";
+import { useAnnouncer } from "../../../composables/useAnnouncer.js";
+import { n as chevron_left_default, t as chevron_right_default } from "../../../chunks/chevron-right-BfqMVpbB.js";
+import { a as emptyStateClass, c as toolbarSeparatorClass, i as chromeButtonClass, l as toolbarShellClass, o as scrimClass, r as badgeClass, s as toolbarButtonClass } from "../../../chunks/config-BeZRuonp.js";
+import { Fragment, Teleport, Transition, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, guardReactiveProps, markRaw, mergeProps, nextTick, normalizeClass, normalizeProps, normalizeStyle, onBeforeUnmount, openBlock, ref, renderSlot, toDisplayString, toHandlers, unref, watch, withCtx } from "vue";
+//#region ~icons/lucide/download
+var _hoisted_1$4 = {
+	viewBox: "0 0 24 24",
+	width: "1.2em",
+	height: "1.2em"
+};
+function render$4(_ctx, _cache) {
+	return openBlock(), createElementBlock("svg", _hoisted_1$4, [..._cache[0] || (_cache[0] = [createElementVNode("g", {
+		fill: "none",
+		stroke: "currentColor",
+		"stroke-linecap": "round",
+		"stroke-linejoin": "round",
+		"stroke-width": "2"
+	}, [createElementVNode("path", { d: "M12 15V3m9 12v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" }), createElementVNode("path", { d: "m7 10l5 5l5-5" })], -1)])]);
+}
+var download_default = markRaw({
+	name: "lucide-download",
+	render: render$4
+});
+//#endregion
+//#region ~icons/lucide/plus
+var _hoisted_1$3 = {
+	viewBox: "0 0 24 24",
+	width: "1.2em",
+	height: "1.2em"
+};
+function render$3(_ctx, _cache) {
+	return openBlock(), createElementBlock("svg", _hoisted_1$3, [..._cache[0] || (_cache[0] = [createElementVNode("path", {
+		fill: "none",
+		stroke: "currentColor",
+		"stroke-linecap": "round",
+		"stroke-linejoin": "round",
+		"stroke-width": "2",
+		d: "M5 12h14m-7-7v14"
+	}, null, -1)])]);
+}
+var plus_default = markRaw({
+	name: "lucide-plus",
+	render: render$3
+});
+//#endregion
+//#region ~icons/lucide/rotate-ccw
+var _hoisted_1$2 = {
+	viewBox: "0 0 24 24",
+	width: "1.2em",
+	height: "1.2em"
+};
+function render$2(_ctx, _cache) {
+	return openBlock(), createElementBlock("svg", _hoisted_1$2, [..._cache[0] || (_cache[0] = [createElementVNode("g", {
+		fill: "none",
+		stroke: "currentColor",
+		"stroke-linecap": "round",
+		"stroke-linejoin": "round",
+		"stroke-width": "2"
+	}, [createElementVNode("path", { d: "M3 12a9 9 0 1 0 9-9a9.75 9.75 0 0 0-6.74 2.74L3 8" }), createElementVNode("path", { d: "M3 3v5h5" })], -1)])]);
+}
+var rotate_ccw_default = markRaw({
+	name: "lucide-rotate-ccw",
+	render: render$2
+});
+//#endregion
+//#region ~icons/lucide/rotate-cw
+var _hoisted_1$1 = {
+	viewBox: "0 0 24 24",
+	width: "1.2em",
+	height: "1.2em"
+};
+function render$1(_ctx, _cache) {
+	return openBlock(), createElementBlock("svg", _hoisted_1$1, [..._cache[0] || (_cache[0] = [createElementVNode("g", {
+		fill: "none",
+		stroke: "currentColor",
+		"stroke-linecap": "round",
+		"stroke-linejoin": "round",
+		"stroke-width": "2"
+	}, [createElementVNode("path", { d: "M21 12a9 9 0 1 1-9-9c2.52 0 4.93 1 6.74 2.74L21 8" }), createElementVNode("path", { d: "M21 3v5h-5" })], -1)])]);
+}
+var rotate_cw_default = markRaw({
+	name: "lucide-rotate-cw",
+	render: render$1
+});
+//#endregion
+//#region src/components/GrImageViewer/composables/useZoomPan.ts
+var TRAILING_ZERO_DECIMAL_RE = /\.0$/;
+function formatPercent(value) {
+	if (Number.isInteger(value)) return String(value);
+	return value.toFixed(1).replace(TRAILING_ZERO_DECIMAL_RE, "");
+}
+/**
+* useZoomPan — состояние и логика масштаба/поворота/панорамирования картинки,
+* а также метрики (натуральный/вписанный/фактический размер, реальный масштаб).
+*/
+function useZoomPan(options) {
+	const scale = ref(1);
+	const rotation = ref(0);
+	const offsetX = ref(0);
+	const offsetY = ref(0);
+	const isDragging = ref(false);
+	let dragStartX = 0;
+	let dragStartY = 0;
+	let dragOffsetStartX = 0;
+	let dragOffsetStartY = 0;
+	const naturalWidth = ref(0);
+	const naturalHeight = ref(0);
+	const fittedWidth = ref(0);
+	const fittedHeight = ref(0);
+	let resizeObserver = null;
+	const imageStyle = computed(() => ({ transform: `translate3d(${offsetX.value}px, ${offsetY.value}px, 0) scale(${scale.value}) rotate(${rotation.value}deg)` }));
+	const zoomValueText = computed(() => formatPercent(scale.value * 100));
+	const renderedWidth = computed(() => Math.round(fittedWidth.value * scale.value));
+	const renderedHeight = computed(() => Math.round(fittedHeight.value * scale.value));
+	const realScale = computed(() => {
+		if (!naturalWidth.value) return 0;
+		return fittedWidth.value * scale.value / naturalWidth.value;
+	});
+	const realScalePercent = computed(() => formatPercent(realScale.value * 100));
+	/** Увеличенный кадр тянется всегда: иначе до его краёв не добраться вовсе. */
+	const isPannable = computed(() => options.draggable() || scale.value > 1);
+	/**
+	* Граница смещения по осям экрана.
+	*
+	* Тянуть имеет смысл ровно настолько, насколько кадр вылез за область
+	* просмотра, — дальше пользователь утаскивает картинку в пустоту и достаёт её
+	* только сбросом. Поворот на 90°/270° меняет оси местами, поэтому границы
+	* считаются по bounding box повёрнутого footprint'а.
+	*/
+	function panBounds() {
+		const viewport = options.viewportEl.value;
+		if (!viewport) return {
+			x: 0,
+			y: 0
+		};
+		const quarterTurns = Math.abs(Math.round(rotation.value / 90) % 2);
+		const width = quarterTurns === 1 ? renderedHeight.value : renderedWidth.value;
+		const height = quarterTurns === 1 ? renderedWidth.value : renderedHeight.value;
+		return {
+			x: Math.max(0, (width - viewport.clientWidth) / 2),
+			y: Math.max(0, (height - viewport.clientHeight) / 2)
+		};
+	}
+	function clampOffsets() {
+		const bounds = panBounds();
+		offsetX.value = Math.min(bounds.x, Math.max(-bounds.x, offsetX.value));
+		offsetY.value = Math.min(bounds.y, Math.max(-bounds.y, offsetY.value));
+	}
+	function clampScale(value) {
+		const clamped = Math.min(options.maxScale(), Math.max(options.minScale(), value));
+		return Number(clamped.toFixed(4));
+	}
+	function setScale(value) {
+		scale.value = clampScale(value);
+		clampOffsets();
+	}
+	/**
+	* Масштаб с якорем: точка под курсором (или между пальцами) остаётся на
+	* месте. Без этого зум всегда идёт от центра, и увеличить нужный угол кадра
+	* можно только зумом с последующим таскиванием.
+	*/
+	function setScaleAt(value, anchor) {
+		const viewport = options.viewportEl.value;
+		const previous = scale.value;
+		const next = clampScale(value);
+		if (next === previous) return;
+		if (anchor && viewport) {
+			const rect = viewport.getBoundingClientRect();
+			const anchorX = anchor.clientX - (rect.left + rect.width / 2);
+			const anchorY = anchor.clientY - (rect.top + rect.height / 2);
+			const ratio = next / previous;
+			offsetX.value = anchorX - (anchorX - offsetX.value) * ratio;
+			offsetY.value = anchorY - (anchorY - offsetY.value) * ratio;
+		}
+		scale.value = next;
+		clampOffsets();
+	}
+	function zoomIn(anchor) {
+		setScaleAt(scale.value * options.zoomRate(), anchor);
+	}
+	function zoomOut(anchor) {
+		setScaleAt(scale.value / options.zoomRate(), anchor);
+	}
+	function rotateLeft() {
+		rotation.value -= 90;
+		clampOffsets();
+		options.onRotate(rotation.value);
+	}
+	function rotateRight() {
+		rotation.value += 90;
+		clampOffsets();
+		options.onRotate(rotation.value);
+	}
+	/**
+	* Масштаб «один к одному»: пиксель картинки на пиксель экрана.
+	*
+	* Считается от вписанного размера, потому что `scale` номинальный — единица
+	* означает «вписано в окно», а не «натуральный размер». У крупного кадра
+	* реальные 100% приходятся на номинальные 6–8×, и вручную такую кнопку
+	* потребителю пришлось бы собирать из `naturalWidth`/`renderedWidth`.
+	*
+	* Потолок `maxScale` действует и здесь: он ограничивает зум сознательно, и
+	* «один к одному» — не повод его обойти. Если кадру нужно больше, поднимите
+	* `maxScale`.
+	*/
+	function zoomToNatural() {
+		if (!naturalWidth.value || !fittedWidth.value) return;
+		setScale(naturalWidth.value / fittedWidth.value);
+	}
+	function resetTransform() {
+		scale.value = 1;
+		rotation.value = 0;
+		offsetX.value = 0;
+		offsetY.value = 0;
+		isDragging.value = false;
+	}
+	function resetImageMetrics() {
+		naturalWidth.value = 0;
+		naturalHeight.value = 0;
+		fittedWidth.value = 0;
+		fittedHeight.value = 0;
+	}
+	function measureFitted() {
+		const el = options.imageEl.value;
+		if (!el) return;
+		fittedWidth.value = el.offsetWidth;
+		fittedHeight.value = el.offsetHeight;
+		clampOffsets();
+	}
+	function onImageLoad(event) {
+		const el = event.target;
+		naturalWidth.value = el.naturalWidth;
+		naturalHeight.value = el.naturalHeight;
+		measureFitted();
+	}
+	function startObservingImage() {
+		const el = options.imageEl.value;
+		if (!el || typeof ResizeObserver === "undefined") return;
+		if (!resizeObserver) resizeObserver = new ResizeObserver(() => measureFitted());
+		resizeObserver.observe(el);
+		if (el.complete && el.naturalWidth) {
+			naturalWidth.value = el.naturalWidth;
+			naturalHeight.value = el.naturalHeight;
+		}
+		measureFitted();
+	}
+	function stopObservingImage() {
+		resizeObserver?.disconnect();
+	}
+	/** Начало перетаскивания: используется и мышью, и жестами. */
+	function startPan(x, y) {
+		isDragging.value = true;
+		dragStartX = x;
+		dragStartY = y;
+		dragOffsetStartX = offsetX.value;
+		dragOffsetStartY = offsetY.value;
+	}
+	function movePan(x, y) {
+		if (!isDragging.value) return;
+		offsetX.value = dragOffsetStartX + (x - dragStartX);
+		offsetY.value = dragOffsetStartY + (y - dragStartY);
+		clampOffsets();
+	}
+	function endPan() {
+		isDragging.value = false;
+	}
+	function onPointerDown(event) {
+		if (!isPannable.value || event.button !== 0) return;
+		event.preventDefault();
+		startPan(event.clientX, event.clientY);
+		event.currentTarget.setPointerCapture?.(event.pointerId);
+	}
+	function onPointerMove(event) {
+		movePan(event.clientX, event.clientY);
+	}
+	function onPointerUp(event) {
+		if (!isDragging.value) return;
+		endPan();
+		event.currentTarget.releasePointerCapture?.(event.pointerId);
+	}
+	return {
+		scale,
+		rotation,
+		offsetX,
+		offsetY,
+		isDragging,
+		isPannable,
+		naturalWidth,
+		naturalHeight,
+		fittedWidth,
+		fittedHeight,
+		imageStyle,
+		zoomValueText,
+		renderedWidth,
+		renderedHeight,
+		realScale,
+		realScalePercent,
+		setScale,
+		setScaleAt,
+		zoomIn,
+		zoomOut,
+		zoomToNatural,
+		rotateLeft,
+		rotateRight,
+		resetTransform,
+		resetImageMetrics,
+		measureFitted,
+		clampOffsets,
+		onImageLoad,
+		startObservingImage,
+		stopObservingImage,
+		startPan,
+		movePan,
+		endPan,
+		onPointerDown,
+		onPointerMove,
+		onPointerUp
+	};
+}
+//#endregion
+//#region src/components/GrImageViewer/composables/useWheelGesture.ts
+var WHEEL_ZOOM_SENSITIVITY = .0015;
+var WHEEL_IDLE_MS = 120;
+/**
+* useWheelGesture — масштабирование колесом мыши / жестом трекпада с батчингом
+* по `requestAnimationFrame` (рендер не чаще кадра — без «дёрганья»/наслоения) и
+* временным отключением CSS-перехода на время жеста (`isWheelZooming`).
+*/
+function useWheelGesture(options) {
+	const isWheelZooming = ref(false);
+	let pendingWheelDelta = 0;
+	let wheelFrameId = null;
+	let wheelIdleTimer = null;
+	let anchor = {
+		clientX: 0,
+		clientY: 0
+	};
+	function cancelWheelFrame() {
+		if (wheelFrameId !== null) {
+			cancelAnimationFrame(wheelFrameId);
+			wheelFrameId = null;
+		}
+	}
+	function endWheelZoom() {
+		if (wheelIdleTimer !== null) {
+			clearTimeout(wheelIdleTimer);
+			wheelIdleTimer = null;
+		}
+		isWheelZooming.value = false;
+		pendingWheelDelta = 0;
+		cancelWheelFrame();
+	}
+	function flushWheelZoom() {
+		wheelFrameId = null;
+		const delta = pendingWheelDelta;
+		pendingWheelDelta = 0;
+		if (!delta) return;
+		const factor = Math.exp(-delta * WHEEL_ZOOM_SENSITIVITY);
+		options.applyZoomFactor(factor, anchor);
+	}
+	function onWheel(event) {
+		if (!options.enabled()) return;
+		event.preventDefault();
+		isWheelZooming.value = true;
+		pendingWheelDelta += event.deltaY;
+		anchor = {
+			clientX: event.clientX,
+			clientY: event.clientY
+		};
+		if (wheelFrameId === null) wheelFrameId = requestAnimationFrame(flushWheelZoom);
+		if (wheelIdleTimer !== null) clearTimeout(wheelIdleTimer);
+		wheelIdleTimer = setTimeout(() => {
+			wheelIdleTimer = null;
+			isWheelZooming.value = false;
+		}, WHEEL_IDLE_MS);
+	}
+	return {
+		isWheelZooming,
+		onWheel,
+		endWheelZoom
+	};
+}
+//#endregion
+//#region src/components/GrImageViewer/composables/usePointerGestures.ts
+/** Сколько пикселей должен пройти палец, чтобы это считалось свайпом. */
+var SWIPE_THRESHOLD_PX = 60;
+/** Во сколько раз горизонталь должна превысить вертикаль: иначе это не листание. */
+var SWIPE_AXIS_RATIO = 1.5;
+/**
+* usePointerGestures — сенсорные жесты просмотрщика: pinch-zoom двумя пальцами
+* и горизонтальный свайп для листания.
+*
+* Живёт на тех же pointer-событиях, что и перетаскивание мышью: разделение идёт
+* по числу активных указателей, а не по типу устройства — трекпад и стилус
+* ведут себя как мышь, палец как палец, отдельных веток на `touch*` не нужно.
+*
+* Что делает одиночный жест, решает масштаб: на увеличенном кадре тянуть важнее
+* (иначе до краёв не добраться), на вписанном — листать.
+*/
+function usePointerGestures(options) {
+	const pointers = /* @__PURE__ */ new Map();
+	/** Идёт ли сейчас pinch: на время жеста компонент гасит CSS-переход. */
+	const isPinching = ref(false);
+	let pinchStartDistance = 0;
+	let pinchStartScale = 1;
+	let swipeStartX = 0;
+	let swipeStartY = 0;
+	let isSwipeCandidate = false;
+	function distance(a, b) {
+		return Math.hypot(a.x - b.x, a.y - b.y);
+	}
+	function midpoint(a, b) {
+		return {
+			clientX: (a.x + b.x) / 2,
+			clientY: (a.y + b.y) / 2
+		};
+	}
+	function activePair() {
+		if (pointers.size < 2) return null;
+		const [first, second] = [...pointers.values()];
+		return [first, second];
+	}
+	function onPointerDown(event) {
+		if (!options.enabled() || event.pointerType === "mouse") return;
+		pointers.set(event.pointerId, {
+			x: event.clientX,
+			y: event.clientY
+		});
+		const pair = activePair();
+		if (pair) {
+			options.pan.end();
+			isSwipeCandidate = false;
+			isPinching.value = true;
+			pinchStartDistance = distance(pair[0], pair[1]) || 1;
+			pinchStartScale = options.scale();
+			return;
+		}
+		if (options.scale() > 1) {
+			options.pan.start(event.clientX, event.clientY);
+			return;
+		}
+		isSwipeCandidate = options.canSwipe();
+		swipeStartX = event.clientX;
+		swipeStartY = event.clientY;
+	}
+	function onPointerMove(event) {
+		if (!pointers.has(event.pointerId)) return;
+		pointers.set(event.pointerId, {
+			x: event.clientX,
+			y: event.clientY
+		});
+		const pair = activePair();
+		if (pair && isPinching.value) {
+			const current = distance(pair[0], pair[1]);
+			if (!current) return;
+			options.setScaleAt(pinchStartScale * (current / pinchStartDistance), midpoint(pair[0], pair[1]));
+			return;
+		}
+		if (!isSwipeCandidate) options.pan.move(event.clientX, event.clientY);
+	}
+	function finishSwipe(event) {
+		const deltaX = event.clientX - swipeStartX;
+		const deltaY = event.clientY - swipeStartY;
+		isSwipeCandidate = false;
+		if (Math.abs(deltaX) < SWIPE_THRESHOLD_PX) return;
+		if (Math.abs(deltaX) < Math.abs(deltaY) * SWIPE_AXIS_RATIO) return;
+		if (deltaX < 0) options.onSwipeLeft();
+		else options.onSwipeRight();
+	}
+	function onPointerUp(event) {
+		if (!pointers.has(event.pointerId)) return;
+		const wasSwipeCandidate = isSwipeCandidate;
+		pointers.delete(event.pointerId);
+		if (isPinching.value && pointers.size < 2) {
+			isPinching.value = false;
+			const [remaining] = [...pointers.values()];
+			if (remaining && options.scale() > 1) options.pan.start(remaining.x, remaining.y);
+			return;
+		}
+		if (wasSwipeCandidate) {
+			finishSwipe(event);
+			return;
+		}
+		options.pan.end();
+	}
+	/** Сброс при закрытии, смене кадра и размонтировании. */
+	function reset() {
+		pointers.clear();
+		isPinching.value = false;
+		isSwipeCandidate = false;
+	}
+	return {
+		isPinching,
+		onPointerDown,
+		onPointerMove,
+		onPointerUp,
+		reset
+	};
+}
+//#endregion
+//#region src/components/GrImageViewer/composables/useViewerKeyboard.ts
+/**
+* useViewerKeyboard — клавиатурное управление просмотрщиком: стрелки —
+* переключение, `+`/`-`/`0` — зум/сброс.
+*
+* Esc сюда не входит: он идёт через общий стек dismissible-слоёв
+* (`useDismissible`), иначе просмотрщик, открытый поверх модалки, закрывал бы
+* не себя. Локальный `@keydown` до него всё равно не дошёл бы — стек гасит
+* событие в capture-фазе.
+*/
+function useViewerKeyboard(options) {
+	const { actions } = options;
+	function onKeydown(event) {
+		switch (event.key) {
+			case "ArrowLeft":
+				event.preventDefault();
+				actions.prev();
+				return;
+			case "ArrowRight":
+				event.preventDefault();
+				actions.next();
+				return;
+			case "+":
+			case "=":
+			case "Add":
+				event.preventDefault();
+				actions.zoomIn();
+				return;
+			case "-":
+			case "_":
+			case "Subtract":
+				event.preventDefault();
+				actions.zoomOut();
+				return;
+			case "0":
+				event.preventDefault();
+				actions.reset();
+				break;
+			default:
+		}
+	}
+	return { onKeydown };
+}
+//#endregion
+//#region src/components/GrImageViewer/GrImageViewer.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = ["inert", "aria-label"];
+var _hoisted_2 = { class: "fixed inset-0 overflow-hidden" };
+var _hoisted_3 = { class: "pointer-events-none absolute inset-x-0 top-0 z-30 px-3 py-3 sm:px-6" };
+var _hoisted_4 = { class: "pointer-events-auto flex items-center justify-between gap-3" };
+var _hoisted_5 = { class: "flex items-center gap-2" };
+var _hoisted_6 = ["aria-label"];
+var _hoisted_7 = ["aria-label"];
+var _hoisted_8 = ["aria-label"];
+var _hoisted_9 = { class: "h-full w-full flex items-center justify-center" };
+var _hoisted_10 = ["src", "alt"];
+var _hoisted_11 = { class: "pointer-events-none absolute inset-x-0 bottom-0 z-30 px-3 pb-3 sm:px-6 sm:pb-6" };
+var _hoisted_12 = { class: "pointer-events-auto mx-auto w-full max-w-max" };
+var _hoisted_13 = ["aria-label"];
+var _hoisted_14 = ["aria-label"];
+var _hoisted_15 = ["aria-label"];
+var _hoisted_16 = ["aria-label"];
+var _hoisted_17 = ["aria-label"];
+var _hoisted_18 = ["aria-label"];
+var _hoisted_19 = ["aria-label"];
+//#endregion
+//#region src/components/GrImageViewer/GrImageViewer.vue
+var GrImageViewer_default = /* @__PURE__ */ defineComponent({
+	__name: "GrImageViewer",
+	props: {
+		modelValue: { type: Boolean },
+		urlList: {},
+		initialIndex: { default: 0 },
+		zoomRate: { default: 1.2 },
+		minScale: { default: .5 },
+		maxScale: { default: 5 },
+		hideOnClickModal: {
+			type: Boolean,
+			default: false
+		},
+		closeOnPressEscape: {
+			type: Boolean,
+			default: true
+		},
+		showProgress: {
+			type: Boolean,
+			default: false
+		},
+		showZoomValue: {
+			type: Boolean,
+			default: true
+		},
+		wheelZoom: {
+			type: Boolean,
+			default: true
+		},
+		draggable: {
+			type: Boolean,
+			default: false
+		},
+		zIndexVar: { default: void 0 },
+		closeLabel: { default: void 0 },
+		prevLabel: { default: void 0 },
+		nextLabel: { default: void 0 },
+		zoomInLabel: { default: void 0 },
+		zoomOutLabel: { default: void 0 },
+		resetZoomLabel: { default: void 0 },
+		zoomToNaturalLabel: { default: void 0 },
+		rotateLeftLabel: { default: void 0 },
+		rotateRightLabel: { default: void 0 },
+		showDownload: {
+			type: Boolean,
+			default: false
+		},
+		downloadLabel: { default: void 0 },
+		emptyText: { default: void 0 },
+		ariaLabel: { default: void 0 }
+	},
+	emits: [
+		"update:modelValue",
+		"close",
+		"change",
+		"rotate",
+		"download"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const { t } = useGranularityTranslations();
+		const resolvedCloseLabel = computed(() => props.closeLabel ?? t("gr.imageViewer.close", "Close image viewer"));
+		const resolvedPrevLabel = computed(() => props.prevLabel ?? t("gr.imageViewer.prev", "Previous image"));
+		const resolvedNextLabel = computed(() => props.nextLabel ?? t("gr.imageViewer.next", "Next image"));
+		const resolvedZoomInLabel = computed(() => props.zoomInLabel ?? t("gr.imageViewer.zoomIn", "Zoom in"));
+		const resolvedZoomOutLabel = computed(() => props.zoomOutLabel ?? t("gr.imageViewer.zoomOut", "Zoom out"));
+		const resolvedResetZoomLabel = computed(() => props.resetZoomLabel ?? t("gr.imageViewer.resetZoom", "Reset zoom"));
+		const resolvedZoomToNaturalLabel = computed(() => props.zoomToNaturalLabel ?? t("gr.imageViewer.zoomToNatural", "Actual size (1:1)"));
+		const resolvedRotateLeftLabel = computed(() => props.rotateLeftLabel ?? t("gr.imageViewer.rotateLeft", "Rotate left"));
+		const resolvedRotateRightLabel = computed(() => props.rotateRightLabel ?? t("gr.imageViewer.rotateRight", "Rotate right"));
+		const resolvedDownloadLabel = computed(() => props.downloadLabel ?? t("gr.imageViewer.download", "Download image"));
+		const resolvedEmptyText = computed(() => props.emptyText ?? t("gr.imageViewer.empty", "No image"));
+		const resolvedAriaLabel = computed(() => props.ariaLabel ?? t("gr.imageViewer.label", "Image viewer"));
+		const emit = __emit;
+		const open = computed(() => props.modelValue);
+		const items = computed(() => props.urlList.map((item) => typeof item === "string" ? { src: item } : item));
+		const total = computed(() => items.value.length);
+		const hasImages = computed(() => total.value > 0);
+		const currentIndex = ref(0);
+		const imageEl = ref(null);
+		const stageEl = ref(null);
+		const { scale, rotation, isDragging, naturalWidth, naturalHeight, renderedWidth, renderedHeight, realScale, realScalePercent, imageStyle, zoomValueText, zoomIn, zoomOut, zoomToNatural, rotateLeft, rotateRight, resetTransform, resetImageMetrics, onImageLoad, startObservingImage, stopObservingImage, isPannable, setScaleAt, startPan, movePan, endPan, onPointerDown: onPanPointerDown, onPointerMove: onPanPointerMove, onPointerUp: onPanPointerUp } = useZoomPan({
+			minScale: () => props.minScale,
+			maxScale: () => props.maxScale,
+			zoomRate: () => props.zoomRate,
+			draggable: () => props.draggable,
+			imageEl,
+			viewportEl: stageEl,
+			onRotate: (deg) => emit("rotate", deg)
+		});
+		const { isWheelZooming, onWheel, endWheelZoom } = useWheelGesture({
+			enabled: () => props.wheelZoom && hasImages.value,
+			applyZoomFactor: (factor, anchor) => setScaleAt(scale.value * factor, anchor)
+		});
+		const currentItem = computed(() => hasImages.value ? items.value[currentIndex.value] : void 0);
+		const currentUrl = computed(() => currentItem.value?.src);
+		const currentAlt = computed(() => currentItem.value?.alt ?? "");
+		const displayIndex = computed(() => hasImages.value ? currentIndex.value + 1 : 0);
+		/**
+		* Позицию объявляем только на смене кадра: при открытии её скажет имя диалога.
+		*
+		* Регион общий и живёт вне просмотрщика — он помечен `data-gr-live-region` и
+		* потому не гасится `inert`, которым просмотрщик накрывает страницу.
+		*/
+		const { announce } = useAnnouncer();
+		watch(displayIndex, (index) => {
+			if (!hasImages.value) return;
+			announce(t("gr.imageViewer.position", "Image {index} of {total}", {
+				index,
+				total: total.value
+			}));
+		});
+		const viewerStyle = computed(() => ({ zIndex: `var(${props.zIndexVar ?? "--gr-z-modal"})` }));
+		const { isPinching, onPointerDown: onGesturePointerDown, onPointerMove: onGesturePointerMove, onPointerUp: onGesturePointerUp, reset: resetGestures } = usePointerGestures({
+			enabled: () => hasImages.value,
+			scale: () => scale.value,
+			canSwipe: () => total.value > 1,
+			setScaleAt,
+			pan: {
+				start: startPan,
+				move: movePan,
+				end: endPan
+			},
+			onSwipeLeft: () => next(),
+			onSwipeRight: () => prev()
+		});
+		function onPointerDown(event) {
+			onGesturePointerDown(event);
+			onPanPointerDown(event);
+		}
+		function onPointerMove(event) {
+			onGesturePointerMove(event);
+			onPanPointerMove(event);
+		}
+		function onPointerUp(event) {
+			onGesturePointerUp(event);
+			onPanPointerUp(event);
+		}
+		const imageTransitionClass = computed(() => isWheelZooming.value || isDragging.value || isPinching.value ? "" : "transition-transform duration-[var(--gr-duration-fast)] ease-[var(--gr-ease-out)]");
+		const imageCursorClass = computed(() => {
+			if (!isPannable.value) return "";
+			return isDragging.value ? "cursor-grabbing" : "cursor-grab";
+		});
+		function normalizeIndex(value) {
+			if (!hasImages.value) return 0;
+			return ((Number.isFinite(value) ? Math.trunc(value) : 0) % total.value + total.value) % total.value;
+		}
+		function setIndex(nextIndex, options) {
+			const normalizedIndex = normalizeIndex(nextIndex);
+			if (normalizedIndex === currentIndex.value) return;
+			currentIndex.value = normalizedIndex;
+			resetTransform();
+			resetImageMetrics();
+			endWheelZoom();
+			if (options?.emitSwitch !== false) emit("change", normalizedIndex);
+		}
+		function syncIndexFromInitial() {
+			if (!hasImages.value) {
+				currentIndex.value = 0;
+				return;
+			}
+			currentIndex.value = normalizeIndex(props.initialIndex);
+			resetTransform();
+			resetImageMetrics();
+			endWheelZoom();
+		}
+		/**
+		* Предзагруженные соседи. Держим ссылки, чтобы загрузку можно было оборвать:
+		* сброс `src` у `Image` отменяет незавершённый запрос. Без этого быстрое
+		* перелистывание галереи копит запросы, которые уже никому не нужны.
+		*/
+		let preloadedImages = [];
+		function cancelPreload() {
+			for (const image of preloadedImages) image.src = "";
+			preloadedImages = [];
+		}
+		function preloadAt(index) {
+			const url = items.value[index]?.src;
+			if (!url) return;
+			const image = new Image();
+			image.decoding = "async";
+			image.src = url;
+			preloadedImages.push(image);
+		}
+		function closeViewer() {
+			emit("update:modelValue", false);
+			emit("close");
+		}
+		function prev() {
+			setIndex(currentIndex.value - 1);
+		}
+		function next() {
+			setIndex(currentIndex.value + 1);
+		}
+		const toolbarActions = {
+			close: closeViewer,
+			prev,
+			next,
+			zoomIn,
+			zoomOut,
+			zoomToNatural,
+			reset: resetTransform,
+			rotateLeft,
+			rotateRight,
+			download
+		};
+		__expose(toolbarActions);
+		const toolbarSlotProps = computed(() => ({
+			index: currentIndex.value,
+			src: currentUrl.value,
+			alt: currentAlt.value,
+			displayIndex: displayIndex.value,
+			total: total.value,
+			scale: scale.value,
+			rotation: rotation.value,
+			naturalWidth: naturalWidth.value,
+			naturalHeight: naturalHeight.value,
+			renderedWidth: renderedWidth.value,
+			renderedHeight: renderedHeight.value,
+			realScale: realScale.value,
+			realScalePercent: realScalePercent.value,
+			actions: toolbarActions
+		}));
+		/**
+		* Скачивание текущего кадра.
+		*
+		* Компонент делает очевидное — `<a download>` на текущий `src` — и сообщает о
+		* нажатии событием. Кросс-доменный адрес браузер всё равно скачает не всегда
+		* (атрибут `download` он там игнорирует), поэтому подписанные ссылки и свои
+		* запросы делаются иначе: `showDownload: false` плюс своя кнопка в слоте
+		* `#toolbar-actions`.
+		*/
+		function download() {
+			const item = currentItem.value;
+			if (!item?.src) return;
+			emit("download", {
+				src: item.src,
+				alt: item.alt ?? "",
+				index: currentIndex.value
+			});
+			if (typeof document === "undefined") return;
+			const link = document.createElement("a");
+			link.href = item.src;
+			link.download = "";
+			link.rel = "noopener";
+			document.body.appendChild(link);
+			link.click();
+			link.remove();
+		}
+		const { onKeydown } = useViewerKeyboard({ actions: {
+			close: closeViewer,
+			prev,
+			next,
+			zoomIn,
+			zoomOut,
+			reset: resetTransform
+		} });
+		const panelEl = ref(null);
+		const { rootEl, isMounted, isVisible, inertAttr, portalTarget, teleportEnabled, themeAttrs, onPanelAfterLeave: releasePresence, backdrop } = useModalOverlay(open, closeViewer, {
+			panel: panelEl,
+			closeOnEscape: () => props.closeOnPressEscape,
+			closeOnBackdrop: () => props.hideOnClickModal
+		});
+		watch(() => props.modelValue, async (isOpen) => {
+			if (!isOpen) {
+				stopObservingImage();
+				endWheelZoom();
+				resetGestures();
+				isDragging.value = false;
+				return;
+			}
+			syncIndexFromInitial();
+			await nextTick();
+			startObservingImage();
+		}, { immediate: true });
+		watch(() => props.initialIndex, () => {
+			if (!props.modelValue) return;
+			syncIndexFromInitial();
+		});
+		/**
+		* Список кадров меняется у живой галереи постоянно: догрузилась следующая
+		* страница, заменили один url. Дёрни на любое такое изменение
+		* `syncIndexFromInitial()` — пользователя выбросит на `initialIndex` вместе со
+		* сброшенным зумом и поворотом.
+		*
+		* Держимся кадра, а не позиции: если текущий `src` остался в наборе, идём за
+		* ним (и трансформации не трогаем). Исчез — остаёмся на своём месте в списке,
+		* прижав индекс к границам, и только тогда сбрасываем трансформации: показываем
+		* уже другую картинку.
+		*/
+		watch(items, (next, prev) => {
+			if (!props.modelValue) return;
+			if (!next.length) {
+				currentIndex.value = 0;
+				resetTransform();
+				resetImageMetrics();
+				endWheelZoom();
+				return;
+			}
+			const shownSrc = prev?.[currentIndex.value]?.src;
+			const keptIndex = shownSrc ? next.findIndex((item) => item.src === shownSrc) : -1;
+			if (keptIndex >= 0) {
+				currentIndex.value = keptIndex;
+				return;
+			}
+			currentIndex.value = Math.min(currentIndex.value, next.length - 1);
+			resetTransform();
+			resetImageMetrics();
+			endWheelZoom();
+		}, { deep: true });
+		/**
+		* Соседние кадры греются только у **открытого** просмотрщика: закрытый на
+		* странице не должен тянуть два полноразмерных изображения просто потому, что
+		* он там есть. `new Image()` существует только в браузере — на сервере эта
+		* ветка не выполняется, потому что закрытый просмотрщик до неё не доходит.
+		*/
+		function preloadNeighbours(index) {
+			cancelPreload();
+			if (!props.modelValue || !hasImages.value || total.value < 2) return;
+			preloadAt(normalizeIndex(index - 1));
+			preloadAt(normalizeIndex(index + 1));
+		}
+		watch([currentIndex, open], ([index]) => preloadNeighbours(index), { immediate: true });
+		onBeforeUnmount(() => {
+			stopObservingImage();
+			endWheelZoom();
+			cancelPreload();
+			resetGestures();
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(Teleport, {
+				to: unref(portalTarget),
+				disabled: !unref(teleportEnabled)
+			}, [unref(teleportEnabled) && unref(isMounted) ? (openBlock(), createElementBlock("div", mergeProps({
+				key: 0,
+				ref_key: "rootEl",
+				ref: rootEl
+			}, unref(themeAttrs), {
+				"data-gr-overlay-root": "",
+				inert: unref(inertAttr),
+				class: "fixed inset-0",
+				style: viewerStyle.value,
+				role: "dialog",
+				"aria-modal": "true",
+				"aria-label": resolvedAriaLabel.value,
+				onKeydown: _cache[8] || (_cache[8] = (...args) => unref(onKeydown) && unref(onKeydown)(...args))
+			}), [createElementVNode("div", _hoisted_2, [createVNode(Transition, {
+				appear: "",
+				"enter-active-class": "duration-[var(--gr-duration-fast)] ease-[var(--gr-ease-out)]",
+				"enter-from-class": "opacity-0",
+				"leave-active-class": "duration-[var(--gr-duration-fast)] ease-[var(--gr-ease-in)]",
+				"leave-to-class": "opacity-0"
+			}, {
+				default: withCtx(() => [unref(isVisible) ? (openBlock(), createElementBlock("div", mergeProps({
+					key: 0,
+					"data-gr-image-viewer-overlay": "",
+					class: unref(scrimClass),
+					"aria-hidden": "true"
+				}, toHandlers(unref(backdrop), true)), null, 16)) : createCommentVNode("", true)]),
+				_: 1
+			}), createVNode(Transition, {
+				appear: "",
+				"enter-active-class": "duration-[var(--gr-duration-base)] ease-[var(--gr-ease-out)]",
+				"enter-from-class": "opacity-0 scale-98",
+				"leave-active-class": "duration-[var(--gr-duration-fast)] ease-[var(--gr-ease-in)]",
+				"leave-to-class": "opacity-0 scale-98",
+				onAfterLeave: unref(releasePresence)
+			}, {
+				default: withCtx(() => [unref(isVisible) ? (openBlock(), createElementBlock("div", {
+					key: 0,
+					ref_key: "panelEl",
+					ref: panelEl,
+					"data-gr-image-viewer-panel": "",
+					class: "relative z-10 h-full w-full outline-none",
+					tabindex: "-1"
+				}, [
+					createElementVNode("div", _hoisted_3, [createElementVNode("div", _hoisted_4, [createElementVNode("div", _hoisted_5, [__props.showProgress ? (openBlock(), createElementBlock("div", {
+						key: 0,
+						"data-gr-image-viewer-progress": "",
+						class: normalizeClass(["font-600", unref(badgeClass)])
+					}, toDisplayString(displayIndex.value) + " / " + toDisplayString(total.value), 3)) : createCommentVNode("", true), __props.showZoomValue ? (openBlock(), createElementBlock("div", {
+						key: 1,
+						"data-gr-image-viewer-zoom-value": "",
+						class: normalizeClass(["font-700", unref(badgeClass)])
+					}, toDisplayString(unref(zoomValueText)) + "% ", 3)) : createCommentVNode("", true)]), createElementVNode("button", {
+						type: "button",
+						"data-gr-image-viewer-close": "",
+						"aria-label": resolvedCloseLabel.value,
+						class: normalizeClass(["h-11 w-11", unref(chromeButtonClass)]),
+						onClick: closeViewer
+					}, [createVNode(GrIcon_default, { size: "md" }, {
+						default: withCtx(() => [createVNode(unref(x_default))]),
+						_: 1
+					})], 10, _hoisted_6)])]),
+					createElementVNode("div", {
+						ref_key: "stageEl",
+						ref: stageEl,
+						class: "relative z-10 h-full w-full flex items-center justify-center px-16 py-16 sm:px-24 sm:py-20",
+						onWheel: _cache[1] || (_cache[1] = (...args) => unref(onWheel) && unref(onWheel)(...args))
+					}, [
+						total.value > 1 ? (openBlock(), createElementBlock("button", {
+							key: 0,
+							type: "button",
+							"data-gr-image-viewer-prev": "",
+							"aria-label": resolvedPrevLabel.value,
+							class: normalizeClass(["absolute left-3 top-1/2 z-20 h-12 w-12 -translate-y-1/2 sm:left-6", unref(chromeButtonClass)]),
+							onClick: prev
+						}, [createVNode(GrIcon_default, { size: "lg" }, {
+							default: withCtx(() => [createVNode(unref(chevron_left_default))]),
+							_: 1
+						})], 10, _hoisted_7)) : createCommentVNode("", true),
+						total.value > 1 ? (openBlock(), createElementBlock("button", {
+							key: 1,
+							type: "button",
+							"data-gr-image-viewer-next": "",
+							"aria-label": resolvedNextLabel.value,
+							class: normalizeClass(["absolute right-3 top-1/2 z-20 h-12 w-12 -translate-y-1/2 sm:right-6", unref(chromeButtonClass)]),
+							onClick: next
+						}, [createVNode(GrIcon_default, { size: "lg" }, {
+							default: withCtx(() => [createVNode(unref(chevron_right_default))]),
+							_: 1
+						})], 10, _hoisted_8)) : createCommentVNode("", true),
+						createElementVNode("div", _hoisted_9, [currentUrl.value ? (openBlock(), createElementBlock("img", {
+							key: 0,
+							ref_key: "imageEl",
+							ref: imageEl,
+							"data-gr-image-viewer-image": "",
+							src: currentUrl.value,
+							alt: currentAlt.value,
+							draggable: "false",
+							class: normalizeClass(["max-h-full max-w-full select-none object-contain will-change-transform [touch-action:none]", [imageTransitionClass.value, imageCursorClass.value]]),
+							style: normalizeStyle(unref(imageStyle)),
+							onLoad: _cache[0] || (_cache[0] = (...args) => unref(onImageLoad) && unref(onImageLoad)(...args)),
+							onPointerdown: onPointerDown,
+							onPointermove: onPointerMove,
+							onPointerup: onPointerUp,
+							onPointercancel: onPointerUp
+						}, null, 46, _hoisted_10)) : (openBlock(), createElementBlock("div", {
+							key: 1,
+							class: normalizeClass(unref(emptyStateClass))
+						}, toDisplayString(resolvedEmptyText.value), 3))])
+					], 544),
+					createElementVNode("div", _hoisted_11, [createElementVNode("div", _hoisted_12, [renderSlot(_ctx.$slots, "toolbar", normalizeProps(guardReactiveProps(toolbarSlotProps.value)), () => [createElementVNode("div", { class: normalizeClass(unref(toolbarShellClass)) }, [
+						createElementVNode("button", {
+							type: "button",
+							"data-gr-image-viewer-zoom-out": "",
+							"aria-label": resolvedZoomOutLabel.value,
+							class: normalizeClass(["h-11 min-w-11 px-2 text-[length:var(--gr-text-sm)] leading-[var(--gr-leading-sm)] font-600", unref(toolbarButtonClass)]),
+							onClick: _cache[2] || (_cache[2] = (...args) => unref(zoomOut) && unref(zoomOut)(...args))
+						}, [createVNode(GrIcon_default, { size: "sm" }, {
+							default: withCtx(() => [createVNode(unref(minus_default))]),
+							_: 1
+						})], 10, _hoisted_13),
+						createElementVNode("button", {
+							type: "button",
+							"data-gr-image-viewer-zoom-reset": "",
+							"aria-label": resolvedResetZoomLabel.value,
+							class: normalizeClass(["h-11 min-w-11 px-3 text-[length:var(--gr-text-xs)] leading-[var(--gr-leading-xs)] font-700", unref(toolbarButtonClass)]),
+							onClick: _cache[3] || (_cache[3] = (...args) => unref(resetTransform) && unref(resetTransform)(...args))
+						}, " 100% ", 10, _hoisted_14),
+						createElementVNode("button", {
+							type: "button",
+							"data-gr-image-viewer-zoom-natural": "",
+							"aria-label": resolvedZoomToNaturalLabel.value,
+							class: normalizeClass(["h-11 min-w-11 px-3 text-[length:var(--gr-text-xs)] leading-[var(--gr-leading-xs)] font-700", unref(toolbarButtonClass)]),
+							onClick: _cache[4] || (_cache[4] = (...args) => unref(zoomToNatural) && unref(zoomToNatural)(...args))
+						}, " 1:1 ", 10, _hoisted_15),
+						createElementVNode("button", {
+							type: "button",
+							"data-gr-image-viewer-zoom-in": "",
+							"aria-label": resolvedZoomInLabel.value,
+							class: normalizeClass(["h-11 min-w-11 px-2 text-[length:var(--gr-text-sm)] leading-[var(--gr-leading-sm)] font-600", unref(toolbarButtonClass)]),
+							onClick: _cache[5] || (_cache[5] = (...args) => unref(zoomIn) && unref(zoomIn)(...args))
+						}, [createVNode(GrIcon_default, { size: "sm" }, {
+							default: withCtx(() => [createVNode(unref(plus_default))]),
+							_: 1
+						})], 10, _hoisted_16),
+						__props.showDownload ? (openBlock(), createElementBlock("button", {
+							key: 0,
+							type: "button",
+							"data-gr-image-viewer-download": "",
+							"aria-label": resolvedDownloadLabel.value,
+							class: normalizeClass(["h-11 min-w-11 px-2 text-[length:var(--gr-text-sm)] leading-[var(--gr-leading-sm)] font-600", unref(toolbarButtonClass)]),
+							onClick: download
+						}, [createVNode(GrIcon_default, { size: "sm" }, {
+							default: withCtx(() => [createVNode(unref(download_default))]),
+							_: 1
+						})], 10, _hoisted_17)) : createCommentVNode("", true),
+						_ctx.$slots["toolbar-actions"] ? (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+							createElementVNode("div", {
+								class: normalizeClass(unref(toolbarSeparatorClass)),
+								"aria-hidden": "true"
+							}, null, 2),
+							renderSlot(_ctx.$slots, "toolbar-actions", normalizeProps(guardReactiveProps(toolbarSlotProps.value))),
+							createElementVNode("div", {
+								class: normalizeClass(unref(toolbarSeparatorClass)),
+								"aria-hidden": "true"
+							}, null, 2)
+						], 64)) : (openBlock(), createElementBlock("div", {
+							key: 2,
+							class: normalizeClass(unref(toolbarSeparatorClass)),
+							"aria-hidden": "true"
+						}, null, 2)),
+						createElementVNode("button", {
+							type: "button",
+							"data-gr-image-viewer-rotate-left": "",
+							"aria-label": resolvedRotateLeftLabel.value,
+							class: normalizeClass(["h-11 min-w-11 px-2 text-[length:var(--gr-text-sm)] leading-[var(--gr-leading-sm)] font-600", unref(toolbarButtonClass)]),
+							onClick: _cache[6] || (_cache[6] = (...args) => unref(rotateLeft) && unref(rotateLeft)(...args))
+						}, [createVNode(GrIcon_default, { size: "sm" }, {
+							default: withCtx(() => [createVNode(unref(rotate_ccw_default))]),
+							_: 1
+						})], 10, _hoisted_18),
+						createElementVNode("button", {
+							type: "button",
+							"data-gr-image-viewer-rotate-right": "",
+							"aria-label": resolvedRotateRightLabel.value,
+							class: normalizeClass(["h-11 min-w-11 px-2 text-[length:var(--gr-text-sm)] leading-[var(--gr-leading-sm)] font-600", unref(toolbarButtonClass)]),
+							onClick: _cache[7] || (_cache[7] = (...args) => unref(rotateRight) && unref(rotateRight)(...args))
+						}, [createVNode(GrIcon_default, { size: "sm" }, {
+							default: withCtx(() => [createVNode(unref(rotate_cw_default))]),
+							_: 1
+						})], 10, _hoisted_19)
+					], 2)])])])
+				], 512)) : createCommentVNode("", true)]),
+				_: 3
+			}, 8, ["onAfterLeave"])])], 16, _hoisted_1)) : createCommentVNode("", true)], 8, ["to", "disabled"]);
+		};
+	}
+});
+//#endregion
+export { GrImageViewer_default as t };