{
  "name": "lightbox",
  "component": "UiLightbox",
  "title": "Lightbox",
  "description": "Повноекранна галерея — фото, відео, YouTube, iframe і власні слайди; щипок, збільшення з інерцією, поворот, слайдшоу, повний екран, політ із мініатюри.",
  "status": "stable",
  "docs": "/docs/components/lightbox",
  "markdown": "/registry/docs/components/lightbox.md",
  "api": "/api/component-meta/UiLightbox",
  "registry": "/registry/components/lightbox.json",
  "download": "/registry/downloads/lightbox.zip",
  "schemaVersion": 1,
  "revision": "61f149062f860d8248371d548e93ab231f773006f2a56c20cd512b5ced015acd",
  "dependencies": {},
  "peerDependencies": {
    "vue": "^3.5.41",
    "tailwindcss": "^4.0.0"
  },
  "overrides": {},
  "integration": [],
  "files": [
    {
      "path": "app/assets/css/components.css",
      "url": "/registry/source/app/assets/css/components.css.txt",
      "sha256": "668f83b510e58a28b8702def0eeab944e528b9fc1b94547cf4d5e9b5296e0d8a",
      "content": "/* Shared component foundations. Import after Tailwind, tokens.css and theme.css. */\n\n@layer base {\n  html {\n    /* 15px замість 16px: щільність інтерфейсу, як у решті проєктів.\n       Усі rem-розміри нижче рахуються від цього кореня — h-12 = 45px. */\n    font-size: 15px;\n  }\n\n  body {\n    /* viewport-fit=cover (nuxt.config) пускає сторінку під виріз камери —\n       інакше env(safe-area-inset-*) у компонентах завжди нуль. Хром сайту\n       тому тримає бічні зони сам: на iPhone у ландшафті шапка й текст\n       інакше ховалися б під вирізом. Фіксовані оверлеї рахують зони окремо. */\n    padding-left: env(safe-area-inset-left);\n    padding-right: env(safe-area-inset-right);\n    background-color: var(--bg-main);\n    color: var(--ink);\n    font-family:\n      ui-sans-serif, system-ui, -apple-system, 'Segoe UI', Roboto,\n      'Helvetica Neue', Arial, sans-serif;\n    -webkit-font-smoothing: antialiased;\n  }\n\n  /* Preflight лишає кнопкам системний cursor: default. Інтерактивні кнопки\n     мають однаково сигналізувати про клік незалежно від UI-компонента. */\n  button:not(:disabled) {\n    cursor: pointer;\n  }\n\n  button:disabled {\n    cursor: not-allowed;\n  }\n\n  /* Видиме фокус-кільце. Скидати outline без заміни не можна —\n     керування з клавіатури стає сліпим. Це базовий рівень: компоненти\n     можуть замінити його на focus-visible:ring-*, але НЕ прибрати. */\n  :focus-visible {\n    outline: 2px solid var(--ring);\n    outline-offset: 2px;\n  }\n\n  /* Табличні цифри: інакше колонки чисел «стрибають» при оновленні. */\n  th,\n  td {\n    font-variant-numeric: tabular-nums;\n  }\n\n  /* Заголовки не лишають одне слово на останньому рядку. */\n  h1,\n  h2,\n  h3 {\n    text-wrap: balance;\n  }\n\n  /* Виділення тексту — брендове, а не системне синє, яке в темній темі\n     сперечається з тлом. */\n  ::selection {\n    background-color: color-mix(in oklab, var(--accent-solid) 28%, transparent);\n    color: inherit;\n  }\n\n  /* Плавна прокрутка до якорів змісту — лише тим, хто не просив прибрати\n     рух. Стрибок на 2000px під reduced-motion — саме те, чого просили\n     уникнути. */\n  @media (prefers-reduced-motion: no-preference) {\n    html {\n      scroll-behavior: smooth;\n    }\n  }\n}\n\n/* -------------------------------------------------------------------- */\n/*  Утиліти                                                             */\n/*                                                                      */\n/*  @utility — синтаксис Tailwind v4. У проєкті на v3 ці два класи      */\n/*  треба перенести у @layer utilities або плагін; про це попереджає    */\n/*  сторінка /docs/foundations/tokens.                                  */\n/* -------------------------------------------------------------------- */\n\n@utility scrollbar-thin {\n  scrollbar-width: thin;\n  scrollbar-color: var(--scrollbar-thumb) transparent;\n\n  &::-webkit-scrollbar {\n    width: 8px;\n    height: 8px;\n  }\n\n  &::-webkit-scrollbar-track {\n    background: transparent;\n  }\n\n  &::-webkit-scrollbar-thumb {\n    background-color: var(--scrollbar-thumb);\n    border-radius: 4px;\n  }\n}\n\n@utility scrollbar-none {\n  scrollbar-width: none;\n\n  &::-webkit-scrollbar {\n    display: none;\n  }\n}\n\n@media (prefers-reduced-motion: reduce) {\n  *,\n  *::before,\n  *::after {\n    animation-duration: 0.01ms !important;\n    /* Без скидання затримки анімація з fill-mode: both тримає елемент\n       НЕВИДИМИМ увесь час затримки — hero з каскадом 0/80/160 мс просто\n       з'являвся б по частинах з паузами. */\n    animation-delay: 0ms !important;\n    animation-iteration-count: 1 !important;\n    transition-duration: 0.01ms !important;\n    transition-delay: 0ms !important;\n  }\n}\n\n"
    },
    {
      "path": "app/assets/css/theme.css",
      "url": "/registry/source/app/assets/css/theme.css.txt",
      "sha256": "cf5c81457cdb26b3ddf5e1b21b0e38daa59508d4459361310fd63d15c69c270d",
      "content": "/* ==================================================================== */\n/*  Реєстрація токенів у Tailwind v4                                    */\n/*                                                                      */\n/*  ЄДИНИЙ файл, специфічний для v4. У проєкті на v3 його замінює       */\n/*  public/port/tailwind.v3.config.cjs — а tokens.css лишається тим     */\n/*  самим.                                                              */\n/*                                                                      */\n/*  `inline` — критично. Без нього утиліта копіює ЗНАЧЕННЯ var() у      */\n/*  момент генерації, і перевизначення в .dark перестає діяти: bg-card  */\n/*  назавжди застигає білим. З `inline` утиліта посилається на var(),   */\n/*  тож тему перемикає сам каскад, без dark:-варіантів у компонентах.   */\n/*                                                                      */\n/*  Альфа (bg-primary-900/30) у v4 працює нативно через color-mix(),    */\n/*  тому rgb-триплети з tokens.css тут не потрібні — вони існують суто  */\n/*  заради переносності у v3.                                           */\n/* ==================================================================== */\n\n/* Темна тема — клас, не медіазапит: користувач перемикає її вручну.\n   :where() тримає специфічність на нулі, щоб .dark не вигравав у\n   утиліт, написаних пізніше. */\n@custom-variant dark (&:where(.dark, .dark *));\n\n@theme inline {\n  /* Текст: text-ink / text-muted.\n     Свідомо НЕ text-primary — інакше text-primary (колір тексту) і\n     text-primary-600 (бренд) означали б різні речі під майже\n     однаковою назвою. */\n  --color-ink: var(--ink);\n  --color-muted: var(--ink-muted);\n\n  /* Поверхні: bg-main / bg-card / bg-input / bg-dropdown / bg-hover / bg-subtle */\n  --color-main: var(--bg-main);\n  --color-card: var(--bg-card);\n  --color-input: var(--bg-input);\n  --color-dropdown: var(--bg-dropdown);\n  --color-hover: var(--bg-hover);\n  --color-subtle: var(--bg-subtle);\n  --color-backdrop: var(--backdrop);\n\n  /* Межі: border-line / divide-line / border-line-strong */\n  --color-line: var(--line);\n  --color-line-strong: var(--line-strong);\n\n  /* Брендова шкала: bg-primary-600, text-primary-400, bg-primary-900/30 … */\n  --color-primary-50: var(--brand-50);\n  --color-primary-100: var(--brand-100);\n  --color-primary-200: var(--brand-200);\n  --color-primary-300: var(--brand-300);\n  --color-primary-400: var(--brand-400);\n  --color-primary-500: var(--brand-500);\n  --color-primary-600: var(--brand-600);\n  --color-primary-700: var(--brand-700);\n  --color-primary-800: var(--brand-800);\n  --color-primary-900: var(--brand-900);\n\n  /* Дія: bg-accent-solid / text-accent / text-accent-contrast */\n  --color-accent: var(--accent);\n  --color-accent-solid: var(--accent-solid);\n  --color-accent-solid-hover: var(--accent-solid-hover);\n  --color-accent-contrast: var(--accent-contrast);\n\n  /* Фокус: ring-ring / ring-offset-ring-offset */\n  --color-ring: var(--ring);\n  --color-ring-offset: var(--ring-offset);\n\n  /* Статуси: text-success / bg-success-bg / border-success-line */\n  --color-success: var(--success);\n  --color-success-bg: var(--success-bg);\n  --color-success-line: var(--success-line);\n  --color-warning: var(--warning);\n  --color-warning-bg: var(--warning-bg);\n  --color-warning-line: var(--warning-line);\n  --color-danger: var(--danger);\n  --color-danger-bg: var(--danger-bg);\n  --color-danger-line: var(--danger-line);\n  --color-danger-solid: var(--danger-solid);\n  --color-danger-solid-hover: var(--danger-solid-hover);\n  --color-danger-contrast: var(--danger-contrast);\n  --color-info: var(--info);\n  --color-info-bg: var(--info-bg);\n  --color-info-line: var(--info-line);\n  --color-neutral: var(--neutral);\n  --color-neutral-bg: var(--neutral-bg);\n  --color-neutral-line: var(--neutral-line);\n\n  /* Рейтинг: fill-rating / text-rating */\n  --color-rating: var(--rating);\n\n  /* Радіуси: rounded-control / rounded-card / rounded-overlay */\n  --radius-control: var(--radius-control);\n  --radius-card: var(--radius-card);\n  --radius-overlay: var(--radius-overlay);\n\n  /* Тіні: shadow-card / shadow-raised / shadow-overlay */\n  --shadow-card: var(--shadow-card);\n  --shadow-raised: var(--shadow-raised);\n  --shadow-overlay: var(--shadow-overlay);\n\n  /* Рух: duration-fast / duration-base / duration-slow,\n     ease-out / ease-in / ease-in-out / ease-emphasized.\n     Типова transition без явного duration/ease бере base + ease-out —\n     тобто кожен `transition-colors` у бібліотеці рухається однаково. */\n  --default-transition-duration: var(--duration-base);\n  --default-transition-timing-function: var(--ease-out);\n  --ease-out: var(--ease-out);\n  --ease-in: var(--ease-in);\n  --ease-in-out: var(--ease-in-out);\n  --ease-emphasized: var(--ease-emphasized);\n\n  /* Іменовані анімації: animate-fade-up (поява знизу), animate-check-in\n     (галочка чекбокса). Ключові кадри нижче, поза @theme. */\n  --animate-fade-up: ui-fade-up var(--duration-slow) var(--ease-out) both;\n  --animate-check-in: ui-check-in var(--duration-base) var(--ease-out) both;\n}\n\n@keyframes ui-fade-up {\n  from {\n    opacity: 0;\n    transform: translateY(0.5rem);\n  }\n  to {\n    opacity: 1;\n    transform: none;\n  }\n}\n\n@keyframes ui-check-in {\n  from {\n    opacity: 0;\n    transform: scale(0.6);\n  }\n  to {\n    opacity: 1;\n    transform: scale(1);\n  }\n}\n"
    },
    {
      "path": "app/assets/css/tokens.css",
      "url": "/registry/source/app/assets/css/tokens.css.txt",
      "sha256": "e42cdb612c562a01898fe731fc572e8623e574fb5c295ddc7c639ff04f22d7ca",
      "content": "/* ==================================================================== */\n/*  tatetUI — токени дизайн-системи                                     */\n/*                                                                      */\n/*  Це ЧИСТИЙ CSS без жодного синтаксису Tailwind. Файл копіюється у    */\n/*  проєкт на Tailwind v3 і на Tailwind v4 без змін — різниця лише в    */\n/*  тому, як токени реєструються в утилітах:                            */\n/*    v4 → app/assets/css/theme.css   (@theme inline)                   */\n/*    v3 → public/port/tailwind.v3.config.cjs  (withOpacity)            */\n/*                                                                      */\n/*  Кожен колір оголошено ДВІЧІ:                                        */\n/*    --x      — hex, споживає Tailwind v4 (альфа через color-mix)      */\n/*    --x-rgb  — триплет через кому, споживає Tailwind v3 через         */\n/*               rgba(var(--x-rgb), <alpha>) у шимі withOpacity()       */\n/*                                                                      */\n/*  Кома, а не пробіл: наявні проєкти вже мають withOpacity() саме під  */\n/*  комовий формат, тож файл падає до них без правок їхніх              */\n/*  tailwind.config.js.                                                 */\n/*                                                                      */\n/*  Пари hex↔rgb перевіряє `bun run check:docs` — розійтися вони не     */\n/*  можуть непоміченими.                                                */\n/* ==================================================================== */\n\n/* -------------------------------------------------------------------- */\n/*  Світла тема (за замовчуванням)                                      */\n/* -------------------------------------------------------------------- */\n\n:root {\n  /* Брендова шкала. Бренд — синій.\n     50-200 — світлі підкладки, 400-600 — активні поверхні, 700 — hover\n     суцільних CTA, 800-900 — джерело підкладок з альфою. */\n  --brand-50: #eff6ff;            --brand-50-rgb: 239, 246, 255;\n  --brand-100: #dbeafe;           --brand-100-rgb: 219, 234, 254;\n  --brand-200: #bfdbfe;           --brand-200-rgb: 191, 219, 254;\n  --brand-300: #93c5fd;           --brand-300-rgb: 147, 197, 253;\n  --brand-400: #60a5fa;           --brand-400-rgb: 96, 165, 250;\n  --brand-500: #3b82f6;           --brand-500-rgb: 59, 130, 246;\n  --brand-600: #2563eb;           --brand-600-rgb: 37, 99, 235;\n  --brand-700: #1d4ed8;           --brand-700-rgb: 29, 78, 216;\n  --brand-800: #1e40af;           --brand-800-rgb: 30, 64, 175;\n  --brand-900: #1e3a8a;           --brand-900-rgb: 30, 58, 138;\n\n  /* Текст */\n  --ink: #1a1d21;                 --ink-rgb: 26, 29, 33;\n  --ink-muted: #5b6472;           --ink-muted-rgb: 91, 100, 114;\n\n  /* Поверхні */\n  --bg-main: #f7f8fa;             --bg-main-rgb: 247, 248, 250;\n  --bg-card: #ffffff;             --bg-card-rgb: 255, 255, 255;\n  --bg-input: #ffffff;            --bg-input-rgb: 255, 255, 255;\n  --bg-dropdown: #ffffff;         --bg-dropdown-rgb: 255, 255, 255;\n  --bg-hover: #f1f5f9;            --bg-hover-rgb: 241, 245, 249;\n  --bg-subtle: #f8fafc;           --bg-subtle-rgb: 248, 250, 252;\n  --backdrop: #0f1115;            --backdrop-rgb: 15, 17, 21;\n\n  /* Межі. line — структура (картки, роздільники, краї панелей): м'яка,\n     бо таких ліній на екрані десятки, і кожна зайва одиниця контрасту\n     робить інтерфейс «коробковим». line-strong — наведення й заливки\n     контролів (трек перемикача, порожня зірка): тут контраст несе\n     впізнаваність, тож його не пом'якшуємо разом із line. */\n  --line: #e6e9ee;                --line-rgb: 230, 233, 238;\n  --line-strong: #cbd3dd;         --line-strong-rgb: 203, 211, 221;\n  --scrollbar-thumb: #c3cad4;     --scrollbar-thumb-rgb: 195, 202, 212;\n\n  /* Семантика дії.\n     accent — для ТЕКСТУ та іконок: #1d4ed8 дає 6.29:1 на білому.\n     accent-solid — ЗАЛИВКА кнопки з білим текстом: #2563eb = 4.56:1 (AA).\n     Розділені навмисно: той самий відтінок не може одночасно бути\n     читабельним текстом і достатньо контрастною заливкою під білим. */\n  --accent: #1d4ed8;              --accent-rgb: 29, 78, 216;\n  --accent-solid: #2563eb;        --accent-solid-rgb: 37, 99, 235;\n  --accent-solid-hover: #1d4ed8;  --accent-solid-hover-rgb: 29, 78, 216;\n  --accent-contrast: #ffffff;     --accent-contrast-rgb: 255, 255, 255;\n\n  /* Фокус. Окремі токени, а не «десь взяти accent»: у вихідних\n     проєктах фокус-кільце написане по-різному в кожному компоненті\n     (focus:ring-primary-500/20, outline: 2px solid var(--accent), …).\n     Без єдиного токена контракт доступності не перевіриш автоматично.\n     ring-offset — колір ПІД елементом, щоб кільце було видно й на\n     суцільній кнопці; тому це тло сторінки, а не картки. */\n  --ring: #2563eb;                --ring-rgb: 37, 99, 235;\n  --ring-offset: #f7f8fa;         --ring-offset-rgb: 247, 248, 250;\n\n  /* Статуси. Текстові відтінки темніші за заливкові з тієї ж причини,\n     що accent ≠ accent-solid. */\n  --success: #15803d;             --success-rgb: 21, 128, 61;\n  --success-bg: #dcfce7;          --success-bg-rgb: 220, 252, 231;\n  --success-line: #bbf7d0;        --success-line-rgb: 187, 247, 208;\n  --warning: #b45309;             --warning-rgb: 180, 83, 9;\n  --warning-bg: #fef3c7;          --warning-bg-rgb: 254, 243, 199;\n  --warning-line: #fde68a;        --warning-line-rgb: 253, 230, 138;\n  --danger: #b91c1c;              --danger-rgb: 185, 28, 28;\n  --danger-bg: #fee2e2;           --danger-bg-rgb: 254, 226, 226;\n  --danger-line: #fecaca;         --danger-line-rgb: 254, 202, 202;\n  --danger-solid: #b91c1c;        --danger-solid-rgb: 185, 28, 28;\n  --danger-solid-hover: #991b1b;  --danger-solid-hover-rgb: 153, 27, 27;\n  --danger-contrast: #ffffff;     --danger-contrast-rgb: 255, 255, 255;\n  --info: #0369a1;                --info-rgb: 3, 105, 161;\n  --info-bg: #e0f2fe;             --info-bg-rgb: 224, 242, 254;\n  --info-line: #bae6fd;           --info-line-rgb: 186, 230, 253;\n  --neutral: #475569;             --neutral-rgb: 71, 85, 105;\n  --neutral-bg: #f1f5f9;          --neutral-bg-rgb: 241, 245, 249;\n  --neutral-line: #e2e8f0;        --neutral-line-rgb: 226, 232, 240;\n\n  /* Рейтинг — окрема роль, а не warning: зірка оцінки не є попередженням,\n     і бренд може захотіти власний відтінок (помаранчевий маркетплейсу),\n     не зачепивши статуси. #d97706 на білому — 3.19:1, тобто вище порогу\n     3:1 для графічних елементів (WCAG 1.4.11). */\n  --rating: #d97706;              --rating-rgb: 217, 119, 6;\n\n  /* Палітра аватарів без картинки (UiAvatar tone=\"auto\"): градієнт від → до.\n     Однакова в обох темах; білий текст ≥ 4.5:1 у найсвітлішій точці. */\n  --avatar-0-from: #2563eb;       --avatar-0-from-rgb: 37, 99, 235;\n  --avatar-0-to: #1d4ed8;         --avatar-0-to-rgb: 29, 78, 216;\n  --avatar-1-from: #7c3aed;       --avatar-1-from-rgb: 124, 58, 237;\n  --avatar-1-to: #6d28d9;         --avatar-1-to-rgb: 109, 40, 217;\n  --avatar-2-from: #db2777;       --avatar-2-from-rgb: 219, 39, 119;\n  --avatar-2-to: #be185d;         --avatar-2-to-rgb: 190, 24, 93;\n  --avatar-3-from: #c2410c;       --avatar-3-from-rgb: 194, 65, 12;\n  --avatar-3-to: #9a3412;         --avatar-3-to-rgb: 154, 52, 18;\n  --avatar-4-from: #15803d;       --avatar-4-from-rgb: 21, 128, 61;\n  --avatar-4-to: #166534;         --avatar-4-to-rgb: 22, 101, 52;\n  --avatar-5-from: #0f766e;       --avatar-5-from-rgb: 15, 118, 110;\n  --avatar-5-to: #115e59;         --avatar-5-to-rgb: 17, 94, 89;\n  --avatar-6-from: #0e7490;       --avatar-6-from-rgb: 14, 116, 144;\n  --avatar-6-to: #155e75;         --avatar-6-to-rgb: 21, 94, 117;\n  --avatar-7-from: #dc2626;       --avatar-7-from-rgb: 220, 38, 38;\n  --avatar-7-to: #b91c1c;         --avatar-7-to-rgb: 185, 28, 28;\n\n  /* Семантичні радіуси: контрол / картка / оверлей.\n     Іменовані за РОЛЛЮ, а не за розміром — інакше «зробимо тут трохи\n     кругліше» розповзається по проєкту без жодного правила.\n     Масштаб близький до GNOME (libadwaita: кнопка 9px, картка 12px,\n     діалог 15px): на 7.5 / 11.25 / 15px за кореня 15px інтерфейс читається\n     м'якшим, а щільні контроли h-8 ще не стають «пігулками». */\n  --radius-control: 0.5rem;\n  --radius-card: 0.75rem;\n  --radius-overlay: 1rem;\n\n  /* Семантичні тіні: картка / підняте / оверлей. */\n  --shadow-card: 0 1px 2px rgb(16 24 40 / 0.04), 0 1px 3px rgb(16 24 40 / 0.06);\n  --shadow-raised: 0 4px 12px rgb(16 24 40 / 0.08), 0 2px 4px rgb(16 24 40 / 0.04);\n  --shadow-overlay: 0 16px 48px rgb(16 24 40 / 0.16), 0 4px 12px rgb(16 24 40 / 0.08);\n\n  /* Рух. Тривалості й криві — теж токени, з тієї ж причини, що й радіуси:\n     інакше в кожному компоненті власне число (75, 100, 150, 200, 300 мс),\n     і інтерфейс «дихає» нерівно. Три ролі:\n       fast — hover/active, зміна кольору\n       base — поява випадайок, підказок, перемикачі\n       slow — оверлеї (модалка, drawer), панелі, що їдуть\n     ease-out — для появи (швидкий старт, м'яке гальмування),\n     ease-in — для зникнення, emphasized — для руху, який має відчуватись\n     фізичним (панель, індикатор вкладок). */\n  --duration-fast: 120ms;\n  --duration-base: 180ms;\n  --duration-slow: 260ms;\n  --ease-out: cubic-bezier(0.22, 1, 0.36, 1);\n  --ease-in: cubic-bezier(0.4, 0, 1, 1);\n  --ease-in-out: cubic-bezier(0.65, 0, 0.35, 1);\n  --ease-emphasized: cubic-bezier(0.32, 0.72, 0, 1);\n\n  /* Каркас застосунку */\n  --header-height: 3.25rem;\n\n  /* Нативні контроли (календар <input type=\"date\">, скролбари, автозаповнення)\n     малює браузер, і тему він бере з color-scheme, а не з наших токенів. Без\n     явного значення вони йшли за ОС: у світлому застосунку на темній ОС\n     випадав темний календар. */\n  color-scheme: light;\n}\n\n/* -------------------------------------------------------------------- */\n/*  Темна тема                                                          */\n/*                                                                      */\n/*  Керується класом .dark на <html>, а не медіазапитом — користувач    */\n/*  має мати змогу перемкнути її вручну.                                */\n/* -------------------------------------------------------------------- */\n\n.dark {\n  /* 50-200 — щільні темні еквіваленти світлих підкладок: у темній темі\n     напівпрозорий світлий синій над #101216 дає брудний сірий, тому\n     потрібні готові непрозорі відтінки.\n     700 лишається ТЕМНІШИМ за 600, бо це hover суцільних CTA з білим\n     текстом — світліший hover роняв би контраст.\n     800-900 навпаки СВІТЛІШАЮТЬ: вони працюють лише як джерело підкладок\n     з альфою (bg-primary-900/30), а темний відтінок під 30% альфи над\n     майже чорним тлом не дав би нічого видимого. */\n  --brand-50: #151b26;            --brand-50-rgb: 21, 27, 38;\n  --brand-100: #16202f;           --brand-100-rgb: 22, 32, 47;\n  --brand-200: #1b2a41;           --brand-200-rgb: 27, 42, 65;\n  --brand-300: #2f4a75;           --brand-300-rgb: 47, 74, 117;\n  --brand-400: #60a5fa;           --brand-400-rgb: 96, 165, 250;\n  --brand-500: #3b82f6;           --brand-500-rgb: 59, 130, 246;\n  --brand-600: #2563eb;           --brand-600-rgb: 37, 99, 235;\n  --brand-700: #1d4ed8;           --brand-700-rgb: 29, 78, 216;\n  --brand-800: #4b8bf5;           --brand-800-rgb: 75, 139, 245;\n  --brand-900: #6ba3f8;           --brand-900-rgb: 107, 163, 248;\n\n  --ink: #f1f3f5;                 --ink-rgb: 241, 243, 245;\n  --ink-muted: #9aa4b2;           --ink-muted-rgb: 154, 164, 178;\n\n  --bg-main: #101216;             --bg-main-rgb: 16, 18, 22;\n  --bg-card: #181b20;             --bg-card-rgb: 24, 27, 32;\n  --bg-input: #1c2026;            --bg-input-rgb: 28, 32, 38;\n  --bg-dropdown: #1c2026;         --bg-dropdown-rgb: 28, 32, 38;\n  --bg-hover: #22262e;            --bg-hover-rgb: 34, 38, 46;\n  --bg-subtle: #14171c;           --bg-subtle-rgb: 20, 23, 28;\n  --backdrop: #000000;            --backdrop-rgb: 0, 0, 0;\n\n  /* Лінія ближча до тла й менш синя: холодний відтінок на темному\n     читався жорсткішим за саму різницю яскравості (1.20:1 до картки). */\n  --line: #262a31;                --line-rgb: 38, 42, 49;\n  --line-strong: #3a4150;         --line-strong-rgb: 58, 65, 80;\n  --scrollbar-thumb: #3a4150;     --scrollbar-thumb-rgb: 58, 65, 80;\n\n  /* На #101216 світлий синій читається з контрастом 8.4:1, тож акцентний\n     ТЕКСТ світлішає, а ЗАЛИВКА лишається брендовою і світлішає на hover —\n     на темному тлі це природніший напрямок реакції. */\n  --accent: #60a5fa;              --accent-rgb: 96, 165, 250;\n  --accent-solid: #2563eb;        --accent-solid-rgb: 37, 99, 235;\n  --accent-solid-hover: #3b82f6;  --accent-solid-hover-rgb: 59, 130, 246;\n  --accent-contrast: #ffffff;     --accent-contrast-rgb: 255, 255, 255;\n\n  --ring: #60a5fa;                --ring-rgb: 96, 165, 250;\n  --ring-offset: #101216;         --ring-offset-rgb: 16, 18, 22;\n\n  --success: #4ade80;             --success-rgb: 74, 222, 128;\n  --success-bg: #0f2a1a;          --success-bg-rgb: 15, 42, 26;\n  --success-line: #1a4430;        --success-line-rgb: 26, 68, 48;\n  --warning: #fbbf24;             --warning-rgb: 251, 191, 36;\n  --warning-bg: #2b1f08;          --warning-bg-rgb: 43, 31, 8;\n  --warning-line: #453314;        --warning-line-rgb: 69, 51, 20;\n  --danger: #f87171;              --danger-rgb: 248, 113, 113;\n  --danger-bg: #2c1416;           --danger-bg-rgb: 44, 20, 22;\n  --danger-line: #4a2024;         --danger-line-rgb: 74, 32, 36;\n  --danger-solid: #dc2626;        --danger-solid-rgb: 220, 38, 38;\n  --danger-solid-hover: #b91c1c;  --danger-solid-hover-rgb: 185, 28, 28;\n  --danger-contrast: #ffffff;     --danger-contrast-rgb: 255, 255, 255;\n  --info: #38bdf8;                --info-rgb: 56, 189, 248;\n  --info-bg: #0a2233;             --info-bg-rgb: 10, 34, 51;\n  --info-line: #14384f;           --info-line-rgb: 20, 56, 79;\n  --neutral: #94a3b8;             --neutral-rgb: 148, 163, 184;\n  --neutral-bg: #1c2026;          --neutral-bg-rgb: 28, 32, 38;\n  --neutral-line: #262a31;        --neutral-line-rgb: 38, 42, 49;\n\n  --rating: #fbbf24;              --rating-rgb: 251, 191, 36;\n\n  /* Тіні на темному тлі мусять бути СИЛЬНІШІ: 4% чорного над #101216\n     не видно взагалі, тож картка «злипається» з тлом. */\n  --shadow-card: 0 1px 2px rgb(0 0 0 / 0.4), 0 1px 3px rgb(0 0 0 / 0.3);\n  --shadow-raised: 0 4px 12px rgb(0 0 0 / 0.5), 0 2px 4px rgb(0 0 0 / 0.3);\n  --shadow-overlay: 0 16px 48px rgb(0 0 0 / 0.6), 0 4px 12px rgb(0 0 0 / 0.4);\n\n  color-scheme: dark;\n}\n\n/* -------------------------------------------------------------------- */\n/*  Мобільний каркас                                                    */\n/*                                                                      */\n/*  Шапка на телефоні вища: 3.25rem = 48.75px вистачало під кнопки h-8, */\n/*  але мінімальна ціль для пальця — 44px, і вона мусить поміститися    */\n/*  разом із полями шапки. Межа збігається з md: Tailwind.              */\n/* -------------------------------------------------------------------- */\n\n@media (width < 48rem) {\n  :root {\n    --header-height: 3.5rem;\n  }\n}\n"
    },
    {
      "path": "app/components/ui/UiLightbox.vue",
      "url": "/registry/source/app/components/ui/UiLightbox.vue.txt",
      "sha256": "bb3490624152dce89d75cc5ccf8023c43f702d830566e020f8eea033d3b17ef5",
      "content": "<script setup lang=\"ts\">\nimport { uiText } from '~/composables/useUiText'\nimport { computed, nextTick, onBeforeUnmount, onBeforeUpdate, onMounted, reactive, ref, shallowRef, useId, watch } from 'vue'\nimport UiSpinner from './UiSpinner.vue'\nimport { useFocusTrap } from '~/composables/useFocusTrap'\nimport { useFullscreen } from '~/composables/useFullscreen'\nimport { useOverlayLayer } from '~/composables/useOverlayStack'\nimport { readDurationToken, useReducedMotion } from '~/composables/useReducedMotion'\nimport { useScrollLock } from '~/composables/useScrollLock'\nimport { dragAxis, rubberBandDelta, shouldAdvance, swipeDirection } from '~/utils/carousel'\nimport {\n  DOUBLE_TAP_MS,\n  LIGHTBOX_LABELS_UK,\n  TAP_SLOP_PX,\n  clamp,\n  closeProgress,\n  decay,\n  embedSrc,\n  fitScale,\n  isDoubleTap,\n  isTap,\n  lightboxIndex,\n  lightboxKind,\n  nextSlideshowIndex,\n  originTransform,\n  panBounds,\n  releaseVelocity,\n  rubberband,\n  rubberbandScale,\n  shouldCloseOnDrag,\n  slideKindOf,\n  slideStep,\n  stepZoom,\n  toggleZoomTarget,\n  visibleFraction,\n  wheelZoomFactor,\n  youtubeThumbnail,\n  zoomAround,\n  zoomLimits,\n  type LightboxKind,\n  type LightboxLabels,\n  type Point,\n  type PointerSample,\n  type Rect,\n  type Size,\n} from '~/utils/lightbox'\n\nexport interface LightboxItem {\n  /**\n   * Вид вмісту. Типово — за `src`: посилання YouTube чи Vimeo і файли\n   * .mp4/.webm/.ogv/.mov — відео, решта — зображення. `iframe` — будь-яка\n   * сторінка (мапа, PDF), `custom` — власний вміст через слот `custom`.\n   */\n  type?: 'image' | 'video' | 'iframe' | 'custom'\n  /** Адреса зображення, відеофайлу, відео на YouTube/Vimeo чи сторінки. Для `custom` — будь-який унікальний ключ. */\n  src: string\n  /** Текстова альтернатива зображення або назва відео чи сторінки. Для скрінрідера це і є слайд. */\n  alt: string\n  /** Підпис під слайдом. */\n  caption?: string\n  /** Мініатюра для стрічки й заглушка, поки вантажиться повне зображення. Типово — `src`. */\n  thumbnail?: string\n  /** Набір розмірів зображення. Під час збільшення галерея просить у браузера більший. */\n  srcset?: string\n  /** `sizes` для `srcset`. Типово — `100vw`. */\n  sizes?: string\n  /** Натуральна ширина, px: розмір заглушки до завантаження, пропорції iframe. */\n  width?: number\n  /** Натуральна висота, px. */\n  height?: number\n  /** Кадр-обкладинка відео. */\n  poster?: string\n  /** Адреса для кнопки «Завантажити», коли вона інша, ніж `src`. `false` — не пропонувати. */\n  download?: string | false\n}\n\n/** Попередня назва типу. Лишається, щоб наявні імпорти не зламались. */\nexport type LightboxImage = LightboxItem\n\nconst props = withDefaults(\n  defineProps<{\n    /** Відкрито. Використовуйте через `v-model`. */\n    modelValue?: boolean\n    /**\n     * Поточний слайд. Через `v-model:index`, але працює й без\n     * прив'язки: гортання тоді живе всередині компонента.\n     */\n    index?: number\n    /**\n     * Слайди галереї: зображення, відео (файл, YouTube, Vimeo), сторінки в\n     * iframe або власний вміст (`type: 'custom'` + слот `custom`).\n     */\n    images: LightboxItem[]\n    /** З останнього слайда переходити на перший. */\n    loop?: boolean\n    /** Показувати стрічку мініатюр при відкритті. Сама ховається, коли слайд один. */\n    thumbnails?: boolean\n    /**\n     * Список слайдів ще дотягується — наприклад, чат відкрив одне фото і\n     * підвантажує сусідні. Поки так, стрічка мініатюр і кнопки слайдшоу та\n     * мініатюр займають місце навіть для одного слайда: інакше, коли решта\n     * з'явиться, стрічка відніме висоту в сцени, і фото стрибне. Вимкніть\n     * прапорець, щойно список дотягнувся (або не дотягнувся): одиночний\n     * слайд знову ховає стрічку.\n     */\n    loadingMore?: boolean\n    /**\n     * Збільшення зображень: клік, подвійний дотик, щипок, колесо, `+`/`−`.\n     * Збільшене фото рухається перетягуванням — з інерцією, як на телефоні.\n     */\n    zoomable?: boolean\n    /**\n     * Найбільше збільшення відносно вписаного у вікно розміру. До\n     * натурального розміру великого фото можна дійти завжди.\n     */\n    maxZoom?: number\n    /**\n     * Кнопки верхньої панелі — у цьому порядку. Лічильник і хрестик є\n     * завжди; кнопки, яким нема чого робити, не показуються: повний екран на\n     * iPhone, слайдшоу й мініатюри для одного слайда.\n     */\n    toolbar?: Array<'zoom' | 'zoomIn' | 'zoomOut' | 'rotate' | 'flip' | 'slideshow' | 'fullscreen' | 'thumbnails' | 'download'>\n    /** Перехід між слайдами. `prefers-reduced-motion` вимикає будь-який. */\n    transition?: 'slide' | 'fade' | 'none'\n    /**\n     * Що робить колесо миші. Щипок на тачпаді (Ctrl + колесо) збільшує\n     * завжди — це жест масштабу, а не прокрутки.\n     */\n    wheel?: 'zoom' | 'navigate' | 'none'\n    /** Змах угору чи вниз закриває галерею — як у галереї телефона. */\n    dragToClose?: boolean\n    /** Клік мишею в порожнє поле навколо слайда закриває галерею. */\n    closeOnBackdrop?: boolean\n    /**\n     * Запустити слайдшоу одразу при відкритті. Кнопка паузи тоді є завжди,\n     * а при `prefers-reduced-motion` слайдшоу саме не стартує.\n     */\n    autoplay?: boolean\n    /** Пауза між кадрами слайдшоу, мс. */\n    interval?: number\n    /**\n     * Через скільки мілісекунд без руху миші ховати панелі й стрілки.\n     * `false` — не ховати. На дотику панелі ховає й повертає дотик до фото.\n     */\n    idle?: number | false\n    /**\n     * Мініатюра на сторінці, з якої слайд «виростає» при відкритті й куди\n     * повертається при закритті. Функція від індексу: `(i) => thumbs[i]`.\n     */\n    origin?: (index: number) => Element | null | undefined\n    /**\n     * Перекриття підписів. Задавайте лише ключі, що змінюються; у проєкті з\n     * i18n — об'єкт із `t()`, і зміна мови оновить підписи на льоту.\n     */\n    labels?: Partial<LightboxLabels>\n    /** Доступна назва діалогу. */\n    ariaLabel?: string\n  }>(),\n  {\n    modelValue: false,\n    index: 0,\n    loop: false,\n    thumbnails: true,\n    loadingMore: false,\n    zoomable: true,\n    maxZoom: 4,\n    toolbar: () => ['zoom', 'slideshow', 'fullscreen', 'thumbnails'],\n    transition: 'slide',\n    wheel: 'zoom',\n    dragToClose: true,\n    closeOnBackdrop: true,\n    autoplay: false,\n    interval: 3000,\n    idle: false,\n    origin: undefined,\n    labels: undefined,\n    ariaLabel: 'Перегляд зображень',\n  },\n)\n\ntype Tool = NonNullable<typeof props.toolbar>[number]\n\nconst emit = defineEmits<{\n  'update:modelValue': [value: boolean]\n  'update:index': [value: number]\n  close: []\n}>()\n\ndefineSlots<{\n  /** Додаткові дії у верхній панелі: «Поділитися», «До товару». */\n  actions?: (props: { image: LightboxItem; index: number }) => unknown\n  /** Власний підпис замість `caption` слайда. */\n  caption?: (props: { image: LightboxItem; index: number }) => unknown\n  /** Вміст слайдів із `type: 'custom'`. `active` — чи слайд зараз поточний. */\n  custom?: (props: { image: LightboxItem; index: number; active: boolean }) => unknown\n}>()\n\nconst text = computed<LightboxLabels>(() => ({ ...LIGHTBOX_LABELS_UK, ...(props.labels ?? {}) }))\nconst count = computed(() => props.images.length)\nconst kinds = computed(() => props.images.map((item) => lightboxKind(item)))\nconst kindAt = (index: number): LightboxKind => kinds.value[index] ?? 'image'\n\n/* ------------------------------------------------------------------ */\n/*  Індекс, трек і слайди                                              */\n/* ------------------------------------------------------------------ */\n\n/*\n * Індекс — локальний стан, синхронізований із props, а не чисте\n * відображення props.index. Інакше галерея без `v-model:index` не гортала\n * б узагалі: подія йшла б у нікуди, а props лишався б нулем.\n */\nconst current = ref(lightboxIndex(props.index, count.value))\n/*\n * Віртуальна позиція треку. Слайди стоять на `позиція × 100%`, а трек\n * зсунутий на мінус позицію, тож перехід — це зміна одного числа, яку\n * анімує CSS. Позиція росте без меж і з `loop`: з останнього на перший\n * трек їде вперед, а не пролітає назад через усю галерею.\n */\nconst position = ref(0)\n/*\n * Слайд, що саме виїжджає, тримає свій вміст до кінця анімації. Без цього\n * на дальньому переході (клік по мініатюрі) сусід, що виїжджає, миттєво\n * підміняв би фото на інше.\n */\nconst outgoing = shallowRef<{ vpos: number; index: number } | null>(null)\nlet outgoingTimer: ReturnType<typeof setTimeout> | undefined\n\nconst image = computed<LightboxItem | undefined>(() => props.images[current.value])\nconst currentKind = computed(() => kindAt(current.value))\nconst atStart = computed(() => !props.loop && current.value === 0)\nconst atEnd = computed(() => !props.loop && current.value === count.value - 1)\n\ninterface Panel {\n  vpos: number\n  index: number\n  /** −1 — попередній, 0 — поточний, 1 — наступний. */\n  offset: number\n  item: LightboxItem\n  kind: LightboxKind\n}\n\n/*\n * У DOM — лише три слайди: поточний і два сусіди. Сусіди видно під час\n * свайпу, і їхні зображення вантажаться наперед — гортання галереї\n * послідовне, наступне фото має бути готовим до того, як його попросили.\n * Ключ — віртуальна позиція: після переходу сусід стає поточним тим самим\n * вузлом, без перезавантаження фото.\n */\nconst panels = computed<Panel[]>(() => {\n  const total = count.value\n  const list: Panel[] = []\n  for (const offset of [-1, 0, 1]) {\n    if (!total || (offset !== 0 && total < 2)) continue\n    const vpos = position.value + offset\n    const kept = outgoing.value?.vpos === vpos ? outgoing.value.index : null\n    const raw = current.value + offset\n    const index = kept ?? (props.loop ? lightboxIndex(raw, total, true) : raw)\n    const item = props.images[index]\n    if (!item) continue\n    list.push({ vpos, index, offset, item, kind: kindAt(index) })\n  }\n  return list\n})\n\nconst reducedMotion = useReducedMotion()\nconst trackEl = ref<HTMLElement | null>(null)\nlet trackDrag = 0\n\nfunction slideMs(): number {\n  if (reducedMotion.value || props.transition === 'none') return 0\n  return readDurationToken('--duration-slow', 260)\n}\n\n/*\n * Трек рухається імперативно, а не через :style. Під пальцем зсув\n * змінюється щокадру, і реактивний стиль перемальовував би весь компонент\n * разом зі стрічкою мініатюр на кожен pointermove.\n */\nfunction applyTrack(animate: boolean) {\n  const track = trackEl.value\n  if (!track) return\n  const shift = props.transition === 'fade' ? 0 : -position.value * 100\n  track.style.transition =\n    animate && slideMs() > 0 ? 'transform var(--duration-slow) var(--ease-emphasized)' : 'none'\n  track.style.transform = `translate3d(calc(${shift}% + ${trackDrag}px), 0, 0)`\n}\n\nfunction moveTo(target: number, step: 1 | -1) {\n  if (target === current.value || !count.value) return\n  rescueFocus()\n  stopInertia()\n  const from = { vpos: position.value, index: current.value }\n  current.value = target\n  position.value += step\n  outgoing.value = from\n  trackDrag = 0\n  resetView()\n  emit('update:index', target)\n  applyTrack(true)\n  clearTimeout(outgoingTimer)\n  outgoingTimer = setTimeout(settleOutgoing, slideMs() + 60)\n}\n\n/** Слайд виїхав — прибираємо з нього збільшення й зсув закриття: він сусід. */\nfunction settleOutgoing() {\n  outgoing.value = null\n  for (const [vpos, element] of imgEls) {\n    if (vpos === position.value) continue\n    element.style.transition = ''\n    element.style.transform = ''\n  }\n  for (const [vpos, element] of boxEls) {\n    if (vpos === position.value) continue\n    element.style.transition = ''\n    element.style.transform = ''\n  }\n}\n\nfunction goTo(target: number) {\n  if (!count.value) return\n  const next = lightboxIndex(target, count.value, props.loop)\n  if (next === current.value) return\n  if (!props.modelValue || !trackEl.value) {\n    current.value = next\n    emit('update:index', next)\n    return\n  }\n  moveTo(next, slideStep(current.value, next, count.value, props.loop))\n}\n\nfunction previous() {\n  if (count.value > 1 && !atStart.value) moveTo(lightboxIndex(current.value - 1, count.value, props.loop), -1)\n}\n\nfunction next() {\n  if (count.value > 1 && !atEnd.value) moveTo(lightboxIndex(current.value + 1, count.value, props.loop), 1)\n}\n\n// Стрічку мініатюр після стрибка нумерації не гортаємо плавно: див. watch нижче.\nlet instantStrip = false\n\nfunction sameSources(a: LightboxItem[], b: LightboxItem[]): boolean {\n  return a.length === b.length && a.every((item, at) => item.src === b[at]?.src)\n}\n\n/*\n * Індекс і список змінюються разом, коли батько підмінює набір слайдів під\n * відкритою галереєю: чат відкрив альбом, а потім дотягнув усі фото чату, і\n * відкрите фото стоїть уже під іншим номером. Слайд на екрані той самий, тож\n * стаємо на новий номер на місці. Анімований перехід (moveTo) тут шкодить\n * тричі: виїжджав би слайд зі старого номера — а там у новому списку чужа\n * картинка; нове фото монтувалося б заново, і між заглушкою та фото були б\n * порожні кадри; стрічка мініатюр їхала б через десятки кнопок.\n */\nwatch(\n  [() => props.images, () => props.index],\n  ([list, value], [previousList, previousValue]) => {\n    const target = lightboxIndex(value, list.length)\n    if (props.modelValue && trackEl.value && value !== previousValue && list !== previousList) {\n      const shown = previousList[current.value]\n      if (shown && target !== current.value && list[target]?.src === shown.src && !sameSources(list, previousList)) {\n        instantStrip = true\n        outgoing.value = null\n        current.value = target\n        return\n      }\n    }\n    if (target === current.value) return\n    // Галерею щойно відкривають уже з новим індексом (трек ще не\n    // відрендерено) — стаємо на місце одразу, без проїзду від старого.\n    if (!props.modelValue || !trackEl.value) current.value = target\n    else moveTo(target, slideStep(current.value, target, count.value, props.loop))\n  },\n)\n\nwatch(count, (total) => {\n  current.value = lightboxIndex(current.value, total)\n  outgoing.value = null\n})\n\n// Той самий індекс, але інший набір (полива товару змінилась) — інше фото.\nwatch(\n  () => image.value?.src,\n  () => {\n    if (props.modelValue) resetView()\n  },\n)\n\n/* ------------------------------------------------------------------ */\n/*  Завантаження                                                       */\n/* ------------------------------------------------------------------ */\n\nconst loadStates = reactive<Record<string, 'loaded' | 'failed'>>({})\nconst retries = reactive<Record<string, number>>({})\nconst stateOf = (item?: LightboxItem) => (item ? loadStates[item.src] : undefined)\n\nconst currentLoaded = computed(() => currentKind.value === 'custom' || stateOf(image.value) === 'loaded')\nconst currentFailed = computed(() => stateOf(image.value) === 'failed')\n\nfunction markLoaded(item: LightboxItem) {\n  loadStates[item.src] = 'loaded'\n}\n\nfunction markFailed(item: LightboxItem) {\n  loadStates[item.src] = 'failed'\n}\n\nfunction retry() {\n  const item = image.value\n  if (!item) return\n  delete loadStates[item.src]\n  retries[item.src] = (retries[item.src] ?? 0) + 1\n}\n\nconst imgEls = new Map<number, HTMLImageElement>()\nconst boxEls = new Map<number, HTMLElement>()\n\n/*\n * «Готове» — це розкодоване, а не лише завантажене. Зображення має\n * decoding=\"async\": подія load приходить, коли файл дійшов, а розкодування\n * ще йде поза потоком, і на екрані до першої відмальовки порожньо. Заглушку-\n * мініатюру за load уже прибрали б — і між нею та фото лишалося б кілька\n * порожніх кадрів. Тому слайд вважаємо готовим після decode(). Там, де його\n * немає (тестове середовище), — одразу.\n */\nconst decodeQueue = new WeakMap<HTMLImageElement, Array<() => void>>()\n\nfunction whenDecoded(element: HTMLImageElement, done: () => void) {\n  if (typeof element.decode !== 'function') {\n    done()\n    return\n  }\n  const queue = decodeQueue.get(element)\n  if (queue) {\n    queue.push(done)\n    return\n  }\n  decodeQueue.set(element, [done])\n  // Відмова decode() (пошкоджене зображення, яке все ж завантажилось) — не\n  // привід тримати слайд «неготовим»: показуємо, як є.\n  const settle = () => {\n    const callbacks = decodeQueue.get(element) ?? []\n    decodeQueue.delete(element)\n    for (const callback of callbacks) callback()\n  }\n  element.decode().then(settle, settle)\n}\n\n// Зображення з кешу вже `complete` на момент монтування — події load для\n// нього може не бути, і без цієї перевірки спінер крутився б над готовим фото.\nfunction setImgEl(panel: Panel, element: unknown) {\n  if (element instanceof HTMLImageElement) {\n    imgEls.set(panel.vpos, element)\n    if (element.complete && element.naturalWidth > 0 && !stateOf(panel.item)) {\n      whenDecoded(element, () => markLoaded(panel.item))\n    }\n  } else {\n    imgEls.delete(panel.vpos)\n  }\n}\n\nfunction setBoxEl(vpos: number, element: unknown) {\n  if (element instanceof HTMLElement) boxEls.set(vpos, element)\n  else boxEls.delete(vpos)\n}\n\nfunction onImageLoad(panel: Panel) {\n  const ready = () => {\n    markLoaded(panel.item)\n    // Слайд міг стати сусідом, поки розкодовувався: політ — лише для поточного.\n    if (panel.vpos === position.value && pendingZoomIn) {\n      const inTime = performance.now() < pendingZoomIn\n      pendingZoomIn = 0\n      awaitingZoom.value = false\n      if (inTime) void nextTick(runZoomIn)\n    }\n  }\n  const element = imgEls.get(panel.vpos)\n  if (element) whenDecoded(element, ready)\n  else ready()\n}\n\n/** Мініатюра як заглушка — лише коли вона справді інша, ніж саме фото. */\nfunction placeholderFor(panel: Panel): string | null {\n  const thumbnail = panel.item.thumbnail\n  if (!thumbnail || thumbnail === panel.item.src || awaitingZoom.value) return null\n  return stateOf(panel.item) ? null : thumbnail\n}\n\nfunction naturalBox(item: LightboxItem) {\n  return item.width && item.height ? { maxWidth: `${item.width}px`, maxHeight: `${item.height}px` } : undefined\n}\n\nfunction posterFor(item: LightboxItem, kind: LightboxKind): string | null {\n  return item.poster ?? item.thumbnail ?? (kind === 'youtube' ? youtubeThumbnail(item.src) : null)\n}\n\n/*\n * Ключ мініатюри — адреса (з лічильником для однакових), а не позиція. Коли\n * чат дотягує сусідні фото й нумерація зсувається, наявні кнопки лишаються\n * тими самими вузлами; з позицією в ключі перемонтовувалась би вся стрічка.\n */\nconst thumbKeys = computed(() => {\n  const seen = new Map<string, number>()\n  return props.images.map((item) => {\n    const times = seen.get(item.src) ?? 0\n    seen.set(item.src, times + 1)\n    return times ? `${item.src}#${times}` : item.src\n  })\n})\n\nfunction thumbnailFor(item: LightboxItem, index: number): string | null {\n  const kind = kindAt(index)\n  if (kind === 'image') return item.thumbnail ?? item.src\n  return posterFor(item, kind)\n}\n\n/*\n * Плеєр і iframe — у пропорції 16:9 (або з width/height слайда), вписані в\n * сцену. Одиниці контейнера (cqw/cqh), а не вимірювання в JS: розмір\n * правильний уже в серверному HTML і сам стежить за поворотом телефона.\n */\nfunction frameStyle(panel: Panel) {\n  const { width, height } = panel.item\n  const ratio = width && height ? width / height : panel.kind === 'iframe' ? null : 16 / 9\n  if (!ratio) return { width: '100%', height: '100%' }\n  const limit = width ? `, ${width}px` : ''\n  return { width: `min(100cqw, ${(ratio * 100).toFixed(3)}cqh${limit})`, aspectRatio: String(ratio) }\n}\n\n/*\n * Функціональний ref Vue викликає на кожному оновленні вузла, а не лише при\n * монтуванні: без цього списку будь-який ререндер (сховати панелі, крок\n * слайдшоу) знову запускав би відео, яке людина щойно поставила на паузу.\n */\nconst autoplayed = new WeakSet<HTMLVideoElement>()\nlet videoEl: HTMLVideoElement | null = null\n\n// Відео обрали явно — воно грає одразу. Браузер дозволить звук, бо жест\n// користувача щойно був; якщо ні — play() відхилиться, і лишаться контроли.\nfunction setVideoEl(element: unknown) {\n  videoEl = element instanceof HTMLVideoElement ? element : null\n  if (!videoEl || !props.modelValue || autoplayed.has(videoEl)) return\n  autoplayed.add(videoEl)\n  const playing = videoEl.play?.()\n  if (playing && typeof playing.catch === 'function') playing.catch(() => undefined)\n}\n\n/* ------------------------------------------------------------------ */\n/*  Збільшення, поворот, віддзеркалення                                */\n/* ------------------------------------------------------------------ */\n\nconst stageEl = ref<HTMLElement | null>(null)\n/*\n * Стан перегляду поточного зображення — звичайний об'єкт, а не reactive:\n * під пальцем він змінюється щокадру. Шаблон бачить лише похідні прапорці\n * (`zoomed`, `atMaxZoom`), що змінюються рідко.\n */\nconst view = { scale: 1, x: 0, y: 0 }\nlet closeOffset = 0\nconst rotation = ref(0)\nconst flipX = ref(1)\nconst flipY = ref(1)\nconst zoomed = shallowRef(false)\nconst atMaxZoom = shallowRef(false)\n\nconst canTransform = computed(() => currentKind.value === 'image' && currentLoaded.value && !currentFailed.value)\nconst canZoom = computed(() => props.zoomable && canTransform.value)\n\nconst zoomEl = (): HTMLImageElement | null => (currentKind.value === 'image' ? imgEls.get(position.value) ?? null : null)\n\ninterface Geometry {\n  layout: Size\n  stage: Size\n  base: number\n  min: number\n  max: number\n  naturalRatio: number\n}\n\n/*\n * `offsetWidth`, а не getBoundingClientRect: це розмір, який дав CSS, без\n * нашого ж transform. Від нього рахуються і межі масштабу, і межі зсуву.\n */\nfunction measure(): Geometry | null {\n  const img = zoomEl()\n  const stage = stageEl.value\n  if (!img || !stage || !img.offsetWidth || !img.offsetHeight) return null\n  const layout = { width: img.offsetWidth, height: img.offsetHeight }\n  const box = img.parentElement\n  const base = fitScale({\n    layout,\n    box: { width: box?.clientWidth || stage.clientWidth, height: box?.clientHeight || stage.clientHeight },\n    natural: { width: img.naturalWidth, height: img.naturalHeight },\n    rotation: rotation.value,\n  })\n  const naturalRatio = img.naturalWidth > 0 ? img.naturalWidth / layout.width : 1\n  const { min, max } = zoomLimits({ base, naturalRatio, maxZoom: props.maxZoom })\n  return { layout, stage: { width: stage.clientWidth, height: stage.clientHeight }, base, min, max, naturalRatio }\n}\n\nfunction transformString(): string {\n  return `translate3d(${view.x}px, ${view.y}px, 0) scale(${view.scale * flipX.value}, ${view.scale * flipY.value}) rotate(${rotation.value}deg)`\n}\n\ntype Speed = 'none' | 'fast' | 'base' | 'slow'\n\nfunction applyView(speed: Speed = 'none', geometry: Geometry | null = measure()) {\n  const img = zoomEl()\n  if (img) {\n    img.style.transition = speed === 'none' || reducedMotion.value ? 'none' : `transform var(--duration-${speed}) var(--ease-out)`\n    img.style.transform = transformString()\n  }\n  const base = geometry?.base ?? 1\n  zoomed.value = view.scale > base * 1.01\n  atMaxZoom.value = !!geometry && view.scale >= geometry.max * 0.99\n}\n\nfunction resetView() {\n  stopInertia()\n  view.scale = 1\n  view.x = 0\n  view.y = 0\n  closeOffset = 0\n  rotation.value = 0\n  flipX.value = 1\n  flipY.value = 1\n  applyView('none', null)\n  restoreSizes()\n}\n\n/*\n * Зі `srcset` браузер обирає файл за розміром у верстці, а transform для\n * нього не існує: збільшене вчетверо фото лишалося б тим самим дрібним\n * файлом, тільки розмитим. Підставляємо в `sizes` фактичну ширину — браузер\n * довантажує більший варіант (і ніколи не повертається до меншого).\n */\nfunction upgradeSizes(geometry: Geometry) {\n  const img = zoomEl()\n  if (!img || !image.value?.srcset || view.scale <= geometry.base * 1.2) return\n  const needed = Math.ceil(geometry.layout.width * view.scale)\n  const declared = Number.parseInt(img.sizes, 10)\n  if (!(declared >= needed)) img.sizes = `${needed}px`\n}\n\nfunction restoreSizes() {\n  const img = zoomEl()\n  const item = image.value\n  if (img && item?.srcset) img.sizes = item.sizes ?? '100vw'\n}\n\nfunction zoomTo(scale: number, point: Point = { x: 0, y: 0 }, speed: Speed = 'slow') {\n  const geometry = measure()\n  if (!geometry || !canZoom.value) return\n  stopInertia()\n  const nextScale = clamp(scale, geometry.min, geometry.max)\n  const offset =\n    nextScale <= geometry.base * 1.001\n      ? { x: 0, y: 0 }\n      : zoomAround({ point, offset: view, scale: view.scale, nextScale })\n  const bounds = panBounds({ layout: geometry.layout, stage: geometry.stage, scale: nextScale, rotation: rotation.value })\n  view.scale = nextScale\n  view.x = clamp(offset.x, -bounds.x, bounds.x)\n  view.y = clamp(offset.y, -bounds.y, bounds.y)\n  applyView(speed, geometry)\n  // Збільшив — розглядає: слайдшоу, що перегорнуло б кадр з-під пальця,\n  // тут лише заважає.\n  if (zoomed.value) playing.value = false\n  upgradeSizes(geometry)\n}\n\nfunction toggleZoom(point?: Point) {\n  const geometry = measure()\n  if (!geometry) return\n  if (zoomed.value) zoomTo(geometry.base)\n  else zoomTo(toggleZoomTarget(geometry), point)\n}\n\nfunction zoomIn(point?: Point) {\n  const geometry = measure()\n  if (geometry) zoomTo(stepZoom(view.scale, 1, geometry), point, 'base')\n}\n\nfunction zoomOut(point?: Point) {\n  const geometry = measure()\n  if (geometry) zoomTo(stepZoom(view.scale, -1, geometry), point, 'base')\n}\n\nfunction resetZoom() {\n  const geometry = measure()\n  if (geometry) zoomTo(geometry.base)\n}\n\nfunction panBy(dx: number, dy: number) {\n  const geometry = measure()\n  if (!geometry) return\n  const bounds = panBounds({ layout: geometry.layout, stage: geometry.stage, scale: view.scale, rotation: rotation.value })\n  view.x = clamp(view.x + dx, -bounds.x, bounds.x)\n  view.y = clamp(view.y + dy, -bounds.y, bounds.y)\n  applyView('fast', geometry)\n}\n\n/** Поворот на чверть оберту: `1` — за годинниковою стрілкою, `-1` — проти. */\nfunction rotate(direction: 1 | -1 = 1) {\n  if (!canTransform.value) return\n  stopInertia()\n  playing.value = false\n  rotation.value += direction > 0 ? 90 : -90\n  // Повернуте фото вписується заново: ширина й висота помінялися місцями.\n  const geometry = measure()\n  view.scale = geometry?.base ?? 1\n  view.x = 0\n  view.y = 0\n  applyView('slow', geometry)\n}\n\n/** Віддзеркалення по горизонталі (`x`) чи вертикалі (`y`) — в осях екрана. */\nfunction flip(axis: 'x' | 'y' = 'x') {\n  if (!canTransform.value) return\n  playing.value = false\n  if (axis === 'x') flipX.value *= -1\n  else flipY.value *= -1\n  applyView('slow')\n}\n\n/* ------------------------------------------------------------------ */\n/*  Жести                                                              */\n/* ------------------------------------------------------------------ */\n\ntype Gesture = 'idle' | 'pending' | 'swipe' | 'close' | 'pan' | 'pinch' | 'done'\n\nlet gesture: Gesture = 'idle'\nconst pointers = new Map<number, Point>()\nlet gestureStart: PointerSample = { x: 0, y: 0, t: 0 }\nlet viewStart = { scale: 1, x: 0, y: 0 }\nlet pinchStart = { distance: 1, point: { x: 0, y: 0 }, scale: 1, x: 0, y: 0 }\nlet pinchPoint: Point = { x: 0, y: 0 }\nlet samples: PointerSample[] = []\nlet gestureGeometry: Geometry | null = null\n// Жест, що рушив слайд, не має закінчитись ще й кліком по ньому — інакше\n// кожне перетягування вмикало б збільшення.\nlet swallowClick = false\nlet lastPointerType = 'mouse'\nlet lastTap: PointerSample | null = null\nlet tapTimer: ReturnType<typeof setTimeout> | undefined\nconst grabbing = shallowRef(false)\nconst closeDragging = shallowRef(false)\n\n/*\n * Звідки жест не починається: кнопки й поля (у слоті custom теж), iframe\n * (туди події й так не доходять) і нижня смуга відео, де нативні контроли:\n * перемотування не має перетворюватися на свайп.\n */\nconst NO_GESTURE = 'button, a, input, textarea, select, label, [contenteditable=\"true\"], iframe, audio, [data-lightbox-no-drag]'\n\nfunction gestureAllowed(event: PointerEvent): boolean {\n  const target = event.target\n  if (!(target instanceof Element)) return true\n  if (target.closest(NO_GESTURE)) return false\n  if (target instanceof HTMLVideoElement) {\n    const rect = target.getBoundingClientRect()\n    if (event.clientY > rect.bottom - 56) return false\n  }\n  return true\n}\n\n/** Точка відносно центру сцени — система координат усієї геометрії. */\nfunction stagePoint(clientX: number, clientY: number): Point {\n  const rect = stageEl.value?.getBoundingClientRect()\n  if (!rect) return { x: 0, y: 0 }\n  return { x: clientX - (rect.left + rect.width / 2), y: clientY - (rect.top + rect.height / 2) }\n}\n\n/*\n * Вказівник іде за пальцем і поза сценою: без capture палець, що з'їхав на\n * панель мініатюр, обривав би жест, і слайд смикався б назад.\n */\nfunction capture(event: PointerEvent) {\n  try {\n    stageEl.value?.setPointerCapture(event.pointerId)\n  } catch {\n    // Вказівник уже пішов — жест завершиться на pointerup/cancel.\n  }\n}\n\nfunction onPointerDown(event: PointerEvent) {\n  lastPointerType = event.pointerType\n  if (event.pointerType === 'mouse' && event.button !== 0) return\n  if (!gestureAllowed(event)) return\n  // Основний вказівник — завжди новий жест. Якщо попередній так і не\n  // отримав pointerup (вікно втратило фокус посеред жесту), його запис у\n  // списку глушив би кожен наступний жест мишею.\n  if (event.isPrimary && pointers.size) abandonGesture()\n  if (pointers.size === 0) {\n    stopInertia()\n    pointers.set(event.pointerId, { x: event.clientX, y: event.clientY })\n    gesture = 'pending'\n    gestureStart = { x: event.clientX, y: event.clientY, t: event.timeStamp }\n    viewStart = { ...view }\n    samples = [gestureStart]\n    swallowClick = false\n    return\n  }\n  // Другий палець — щипок. Свайп чи закриття, що почалися першим пальцем,\n  // скасовуються: одночасно гортати й збільшувати не можна.\n  if (pointers.size === 1 && event.pointerType === 'touch' && canZoom.value) {\n    pointers.set(event.pointerId, { x: event.clientX, y: event.clientY })\n    beginPinch(event)\n  }\n}\n\nfunction beginPinch(event: PointerEvent) {\n  if (trackDrag) {\n    trackDrag = 0\n    applyTrack(true)\n  }\n  if (gesture === 'close') cancelCloseDrag()\n  const [a, b] = [...pointers.values()]\n  if (!a || !b) return\n  gestureGeometry = measure()\n  pinchPoint = stagePoint((a.x + b.x) / 2, (a.y + b.y) / 2)\n  pinchStart = {\n    distance: Math.max(1, Math.hypot(b.x - a.x, b.y - a.y)),\n    point: pinchPoint,\n    scale: view.scale,\n    x: view.x,\n    y: view.y,\n  }\n  gesture = 'pinch'\n  swallowClick = true\n  clearTapTimer()\n  lastTap = null\n  grabbing.value = true\n  capture(event)\n}\n\nfunction onPointerMove(event: PointerEvent) {\n  const pointer = pointers.get(event.pointerId)\n  if (!pointer) return\n  pointer.x = event.clientX\n  pointer.y = event.clientY\n  if (gesture === 'pinch') {\n    updatePinch()\n    return\n  }\n  if (gesture !== 'pending' && gesture !== 'swipe' && gesture !== 'close' && gesture !== 'pan') return\n\n  const dx = event.clientX - gestureStart.x\n  const dy = event.clientY - gestureStart.y\n  if (Math.hypot(dx, dy) > TAP_SLOP_PX) swallowClick = true\n  samples.push({ x: event.clientX, y: event.clientY, t: event.timeStamp })\n  if (samples.length > 24) samples.shift()\n\n  if (gesture === 'pending') {\n    if (!decideGesture(dx, dy)) return\n    capture(event)\n  }\n\n  if (gesture === 'swipe') {\n    const single = count.value < 2\n    trackDrag = rubberBandDelta(dx, { atStart: atStart.value || single, atEnd: atEnd.value || single })\n    applyTrack(false)\n  } else if (gesture === 'close') {\n    closeOffset = dy\n    applyCloseOffset(false)\n  } else if (gesture === 'pan') {\n    updatePan(dx, dy)\n  }\n}\n\n/*\n * Незбільшене фото: жест класифікується за домінантною віссю ДО того, як\n * щось рухати (як у UiCarousel) — горизонталь гортає, вертикаль закриває.\n * Збільшене: будь-який рух — це зсув.\n */\nfunction decideGesture(dx: number, dy: number): boolean {\n  if (zoomed.value && zoomEl()) {\n    if (Math.hypot(dx, dy) < 3) return false\n    gesture = 'pan'\n    gestureGeometry = measure()\n  } else {\n    const axis = dragAxis(dx, dy)\n    if (axis === null) return false\n    if (axis === 'x') {\n      gesture = 'swipe'\n    } else if (props.dragToClose) {\n      gesture = 'close'\n      closeDragging.value = true\n    } else {\n      gesture = 'done'\n      return false\n    }\n  }\n  grabbing.value = true\n  clearTapTimer()\n  return true\n}\n\nfunction updatePan(dx: number, dy: number) {\n  const geometry = gestureGeometry\n  if (!geometry) return\n  const bounds = panBounds({ layout: geometry.layout, stage: geometry.stage, scale: view.scale, rotation: rotation.value })\n  let x = viewStart.x + dx\n  // Дотягнули збільшене фото до краю — решту руху забирає трек: наступний\n  // слайд виїжджає, як у галереї телефона, без зменшення назад.\n  if (count.value > 1 && Math.abs(x) > bounds.x) {\n    const edge = Math.sign(x) * bounds.x\n    trackDrag = rubberBandDelta(x - edge, { atStart: atStart.value, atEnd: atEnd.value })\n    x = edge\n  } else {\n    trackDrag = 0\n    x = rubberband(x, bounds.x)\n  }\n  applyTrack(false)\n  view.x = x\n  view.y = rubberband(viewStart.y + dy, bounds.y)\n  applyView('none', geometry)\n}\n\nfunction updatePinch() {\n  const geometry = gestureGeometry\n  const [a, b] = [...pointers.values()]\n  if (!geometry || !a || !b) return\n  const distance = Math.max(1, Math.hypot(b.x - a.x, b.y - a.y))\n  pinchPoint = stagePoint((a.x + b.x) / 2, (a.y + b.y) / 2)\n  const scale = rubberbandScale(pinchStart.scale * (distance / pinchStart.distance), geometry.min, geometry.max)\n  // Деталь під пальцями на початку щипка лишається під ними: спершу\n  // масштаб навколо початкової точки, потім — зсув за рухом пальців.\n  const anchored = zoomAround({ point: pinchStart.point, offset: pinchStart, scale: pinchStart.scale, nextScale: scale })\n  view.scale = scale\n  view.x = anchored.x + pinchPoint.x - pinchStart.point.x\n  view.y = anchored.y + pinchPoint.y - pinchStart.point.y\n  applyView('none', geometry)\n}\n\n/*\n * pointerup і pointercancel слухаємо на window, а не на сцені. Мишу, яку\n * відпустили над панеллю мініатюр до того, як жест визначився (захоплення\n * вказівника ще немає), сцена не почула б — і жест лишився б «натиснутим»:\n * слайд їхав би за курсором без жодної кнопки.\n */\nfunction onWindowPointerEnd(event: PointerEvent) {\n  if (event.type === 'pointercancel') onPointerCancel(event)\n  else onPointerUp(event)\n}\n\nfunction onPointerUp(event: PointerEvent) {\n  if (!pointers.has(event.pointerId)) return\n  pointers.delete(event.pointerId)\n  if (gesture === 'pinch') {\n    settleZoom()\n    // Один палець лишився — чекаємо, поки підніметься і він: продовжувати\n    // ним зсув означало б стрибок під пальцем, що вже не там, де був.\n    if (pointers.size === 0) endGesture()\n    else gesture = 'done'\n    return\n  }\n  if (pointers.size > 0) return\n\n  const dx = event.clientX - gestureStart.x\n  const dy = event.clientY - gestureStart.y\n  const elapsed = event.timeStamp - gestureStart.t\n  samples.push({ x: event.clientX, y: event.clientY, t: event.timeStamp })\n\n  if (gesture === 'swipe') finishSwipe(dx, elapsed)\n  else if (gesture === 'close') finishClose(dy, elapsed)\n  else if (gesture === 'pan') finishPan(elapsed)\n  else if (gesture === 'pending' && event.pointerType === 'touch' && isTap({ dx, dy, elapsedMs: elapsed })) onTap(event)\n  endGesture()\n}\n\nfunction onPointerCancel(event: PointerEvent) {\n  if (!pointers.has(event.pointerId)) return\n  pointers.delete(event.pointerId)\n  if (pointers.size === 0) abandonGesture()\n}\n\n/** Жест обірвано: усе, що встигло зрушити, плавно повертається на місце. */\nfunction abandonGesture() {\n  if (gesture === 'pinch' || gesture === 'pan') settleZoom()\n  if (trackDrag) {\n    trackDrag = 0\n    applyTrack(true)\n  }\n  if (gesture === 'close') cancelCloseDrag()\n  pointers.clear()\n  endGesture()\n}\n\nfunction endGesture() {\n  if (pointers.size === 0) gesture = 'idle'\n  samples = []\n  gestureGeometry = null\n  grabbing.value = false\n  closeDragging.value = false\n}\n\nfunction finishSwipe(distance: number, elapsed: number) {\n  const width = stageEl.value?.clientWidth ?? 0\n  const advance = count.value > 1 && shouldAdvance({ dx: distance, elapsedMs: elapsed, width })\n  const direction = swipeDirection(distance)\n  trackDrag = 0\n  if (advance && direction === 'next' && !atEnd.value) next()\n  else if (advance && direction === 'previous' && !atStart.value) previous()\n  else applyTrack(true)\n}\n\nfunction finishClose(dy: number, elapsed: number) {\n  const height = stageEl.value?.clientHeight ?? 0\n  const velocity = releaseVelocity(samples).y\n  if (shouldCloseOnDrag({ dy, elapsedMs: elapsed, height, velocity })) close()\n  else cancelCloseDrag()\n}\n\nfunction finishPan(elapsed: number) {\n  if (trackDrag) {\n    // Відпустили за краєм фото — вирішує трек: перегорнути чи повернутись.\n    const before = current.value\n    finishSwipe(trackDrag, elapsed)\n    if (current.value === before) settleZoom()\n    return\n  }\n  const geometry = gestureGeometry\n  if (!geometry) return\n  const bounds = panBounds({ layout: geometry.layout, stage: geometry.stage, scale: view.scale, rotation: rotation.value })\n  const outside = Math.abs(view.x) > bounds.x || Math.abs(view.y) > bounds.y\n  if (outside || reducedMotion.value) {\n    view.x = clamp(view.x, -bounds.x, bounds.x)\n    view.y = clamp(view.y, -bounds.y, bounds.y)\n    applyView(outside ? 'base' : 'none', geometry)\n    return\n  }\n  const velocity = releaseVelocity(samples)\n  if (Math.hypot(velocity.x, velocity.y) > 0.1) startInertia(velocity, geometry)\n}\n\n/** Після щипка: масштаб і зсув повертаються в межі — плавно, з точки пальців. */\nfunction settleZoom() {\n  const geometry = gestureGeometry ?? measure()\n  if (!geometry) return\n  const scale = clamp(view.scale, geometry.min, geometry.max)\n  if (scale !== view.scale) {\n    const anchored = zoomAround({ point: pinchPoint, offset: view, scale: view.scale, nextScale: scale })\n    view.scale = scale\n    view.x = anchored.x\n    view.y = anchored.y\n  }\n  if (view.scale <= geometry.base * 1.001) {\n    view.scale = geometry.base\n    view.x = 0\n    view.y = 0\n  }\n  const bounds = panBounds({ layout: geometry.layout, stage: geometry.stage, scale: view.scale, rotation: rotation.value })\n  view.x = clamp(view.x, -bounds.x, bounds.x)\n  view.y = clamp(view.y, -bounds.y, bounds.y)\n  applyView('base', geometry)\n  if (zoomed.value) playing.value = false\n  upgradeSizes(geometry)\n}\n\nlet inertiaFrame = 0\n\n/*\n * Інерція після змаху збільшеного фото. Раніше зсув робила нативна\n * прокрутка, і інерцію давав браузер; з transform вона наша. Кадри —\n * requestAnimationFrame, тож у фоновій вкладці вона просто стоїть.\n */\nfunction startInertia(velocity: Point, geometry: Geometry) {\n  stopInertia()\n  if (typeof requestAnimationFrame === 'undefined') return\n  const bounds = panBounds({ layout: geometry.layout, stage: geometry.stage, scale: view.scale, rotation: rotation.value })\n  let vx = velocity.x\n  let vy = velocity.y\n  let last = performance.now()\n  const step = (now: number) => {\n    const elapsed = Math.min(Math.max(now - last, 0), 32)\n    last = now\n    view.x += vx * elapsed\n    view.y += vy * elapsed\n    if (Math.abs(view.x) >= bounds.x) {\n      view.x = clamp(view.x, -bounds.x, bounds.x)\n      vx = 0\n    }\n    if (Math.abs(view.y) >= bounds.y) {\n      view.y = clamp(view.y, -bounds.y, bounds.y)\n      vy = 0\n    }\n    vx = decay(vx, elapsed)\n    vy = decay(vy, elapsed)\n    applyView('none', geometry)\n    inertiaFrame = Math.hypot(vx, vy) > 0.02 ? requestAnimationFrame(step) : 0\n  }\n  inertiaFrame = requestAnimationFrame(step)\n}\n\nfunction stopInertia() {\n  if (inertiaFrame && typeof cancelAnimationFrame !== 'undefined') cancelAnimationFrame(inertiaFrame)\n  inertiaFrame = 0\n}\n\nfunction clearTapTimer() {\n  clearTimeout(tapTimer)\n  tapTimer = undefined\n}\n\n/*\n * Дотик на телефоні: один — сховати чи показати панелі (фото на весь\n * екран), подвійний — збільшити в точці дотику. Одиночний чекає паузу\n * подвійного дотику, інакше подвійний спершу ховав би панелі.\n */\nfunction onTap(event: PointerEvent) {\n  const sample = { x: event.clientX, y: event.clientY, t: event.timeStamp }\n  const onImage = !!zoomEl() && event.target === zoomEl()\n  if (isDoubleTap(lastTap, sample)) {\n    clearTapTimer()\n    lastTap = null\n    if (onImage && canZoom.value) toggleZoom(stagePoint(sample.x, sample.y))\n    return\n  }\n  lastTap = sample\n  clearTapTimer()\n  const target = event.target\n  if (!onImage && !(target instanceof Element && target.hasAttribute('data-lightbox-backdrop'))) return\n  tapTimer = setTimeout(() => {\n    tapTimer = undefined\n    // Сховані з будь-якої причини (дотиком чи без руху) — дотик повертає.\n    if (chromeHidden.value) {\n      tapHidden.value = false\n      wake()\n    } else {\n      tapHidden.value = true\n    }\n  }, DOUBLE_TAP_MS)\n}\n\nfunction onStageClick(event: MouseEvent) {\n  // Дотик обробляє onTap; синтезований після нього click — не дія.\n  if (lastPointerType === 'touch') return\n  if (swallowClick) {\n    swallowClick = false\n    return\n  }\n  // Другий клік подвійного: перший уже збільшив, і цей мав би одразу\n  // зменшити назад — звичка «двічі клацнути, щоб збільшити» давала б нуль.\n  if (event.detail > 1) return\n  const target = event.target\n  const img = zoomEl()\n  if (img && target === img) {\n    if (canZoom.value) toggleZoom(stagePoint(event.clientX, event.clientY))\n    return\n  }\n  // Клік у порожнє поле навколо слайда — як клік по фону модалки.\n  if (target instanceof Element && target.hasAttribute('data-lightbox-backdrop') && !zoomed.value && props.closeOnBackdrop) {\n    close()\n  }\n}\n\nlet wheelLockUntil = 0\nlet wheelSum = 0\nlet wheelAt = 0\n\nfunction onWheel(event: WheelEvent) {\n  const pinch = event.ctrlKey || event.metaKey\n  if (canZoom.value && (pinch || props.wheel === 'zoom')) {\n    event.preventDefault()\n    const geometry = measure()\n    if (!geometry) return\n    const factor = wheelZoomFactor(event.deltaY, event.deltaMode, pinch, geometry.stage.height)\n    zoomTo(view.scale * factor, stagePoint(event.clientX, event.clientY), pinch ? 'none' : 'fast')\n    return\n  }\n  if (props.wheel !== 'navigate' || zoomed.value || count.value < 2) return\n  // Прокрутка всередині власного вмісту слайда належить йому.\n  if (event.target instanceof Element && event.target.closest('[data-lightbox-custom]')) return\n  event.preventDefault()\n  // Тачпад шле хвіст інерції ще пів секунди після жесту: один змах — один\n  // слайд, а не п'ять. Поки події йдуть без паузи, замок подовжується.\n  if (event.timeStamp < wheelLockUntil) {\n    wheelLockUntil = event.timeStamp + 200\n    return\n  }\n  // Залишок попереднього змаху не додається до нового: інакше легкий\n  // дотик до колеса через хвилину гортав би слайд.\n  if (event.timeStamp - wheelAt > 200) wheelSum = 0\n  wheelAt = event.timeStamp\n  wheelSum += Math.abs(event.deltaX) > Math.abs(event.deltaY) ? event.deltaX : event.deltaY\n  if (Math.abs(wheelSum) < 40) return\n  if (wheelSum > 0) next()\n  else previous()\n  wheelSum = 0\n  wheelLockUntil = event.timeStamp + 300\n}\n\n/* ------------------------------------------------------------------ */\n/*  Закриття змахом                                                    */\n/* ------------------------------------------------------------------ */\n\nconst rootEl = ref<HTMLElement | null>(null)\n\n/*\n * Зсув — на коробці слайда, а не на зображенні: закривати змахом можна й\n * відео, і власний вміст. Фон і панелі гаснуть через CSS-змінну: інлайнова\n * opacity перебила б класи виходу, і фон не згасав би при закритті.\n */\nfunction applyCloseOffset(animate: boolean) {\n  const box = boxEls.get(position.value)\n  if (box) {\n    box.style.transition = animate && !reducedMotion.value ? 'transform var(--duration-base) var(--ease-out)' : 'none'\n    box.style.transform = closeOffset ? `translate3d(0, ${closeOffset}px, 0)` : ''\n  }\n  const progress = closeProgress(closeOffset, stageEl.value?.clientHeight ?? 0)\n  rootEl.value?.style.setProperty('--ui-lightbox-fade', String(1 - progress))\n}\n\nfunction cancelCloseDrag() {\n  closeOffset = 0\n  applyCloseOffset(true)\n}\n\n/* ------------------------------------------------------------------ */\n/*  Панелі: сховати без руху миші чи дотиком                           */\n/* ------------------------------------------------------------------ */\n\nconst tapHidden = shallowRef(false)\nconst idleHidden = shallowRef(false)\nconst chromeHidden = computed(() => tapHidden.value || idleHidden.value)\nlet idleTimer: ReturnType<typeof setTimeout> | undefined\nlet pointerOverChrome = false\n\nfunction focusInChrome(): boolean {\n  const active = typeof document === 'undefined' ? null : document.activeElement\n  if (!(active instanceof Element) || !active.closest('[data-lightbox-chrome]')) return false\n  try {\n    return active.matches(':focus-visible')\n  } catch {\n    return true\n  }\n}\n\nfunction scheduleIdle() {\n  clearTimeout(idleTimer)\n  if (props.idle === false || props.idle <= 0 || !props.modelValue) return\n  idleTimer = setTimeout(() => {\n    // Курсор над панеллю чи фокус із клавіатури на кнопці — людина саме\n    // користується панеллю, ховати її з-під рук не можна.\n    if (pointerOverChrome || focusInChrome()) return\n    idleHidden.value = true\n  }, props.idle)\n}\n\nfunction wake() {\n  idleHidden.value = false\n  scheduleIdle()\n}\n\nfunction onPanelPointerMove(event: PointerEvent) {\n  if (event.pointerType === 'mouse') wake()\n}\n\nfunction onChromePointer(inside: boolean) {\n  pointerOverChrome = inside\n  if (!inside) scheduleIdle()\n}\n\n// Tab дійшов до схованої кнопки — панелі повертаються: фокус на невидимому\n// елементі — це сліпе керування з клавіатури.\nfunction onPanelFocusIn(event: FocusEvent) {\n  if (event.target instanceof Element && event.target.closest('[data-lightbox-chrome]')) {\n    tapHidden.value = false\n    wake()\n  }\n}\n\n/*\n * Панель інструментів і стрічка мініатюр гортаються вбік. Chromium на Tab\n * докручує смугу лише до кнопки, схованої повністю, і то по центру;\n * частково видиму лишає обрізаною разом із фокус-кільцем. `nearest` разом\n * зі scroll-padding смуги показує кнопку цілою. Лише для фокуса з\n * клавіатури: прокрутка посеред кліку чи тапу зсунула б кнопку з-під пальця.\n */\nfunction onStripFocusIn(event: FocusEvent) {\n  const target = event.target as HTMLElement\n  if (target.matches(':focus-visible')) target.scrollIntoView({ block: 'nearest', inline: 'nearest' })\n}\n\n/* ------------------------------------------------------------------ */\n/*  Слайдшоу, повний екран, мініатюри, завантаження                    */\n/* ------------------------------------------------------------------ */\n\nconst fullscreen = useFullscreen()\nconst thumbnailsVisible = shallowRef(props.thumbnails)\n// Один слайд, але решта ще їде (loadingMore): стрічка вже на місці.\nconst growing = computed(() => props.loadingMore && count.value > 0)\nconst showThumbnails = computed(() => thumbnailsVisible.value && (count.value > 1 || growing.value))\n\nconst toolbarItems = computed<Tool[]>(() => {\n  const list = [...new Set(props.toolbar)]\n  // Слайдшоу, що стартує саме, мусить мати паузу (WCAG 2.2.2).\n  if (props.autoplay && !list.includes('slideshow')) list.push('slideshow')\n  return list.filter((tool) => {\n    if (tool === 'zoom' || tool === 'zoomIn' || tool === 'zoomOut') return props.zoomable\n    if (tool === 'slideshow' || tool === 'thumbnails') return count.value > 1 || growing.value\n    if (tool === 'fullscreen') return fullscreen.supported.value\n    return true\n  })\n})\n\nconst playing = shallowRef(false)\nconst slideshowTicking = shallowRef(false)\nconst slideshowCycle = shallowRef(0)\nconst documentHidden = shallowRef(false)\nlet slideshowTimer: ReturnType<typeof setTimeout> | undefined\nconst slideshowAvailable = computed(() => toolbarItems.value.includes('slideshow'))\n\n/*\n * Слайдшоу чекає: поки фото вантажиться (кадр, показаний на пів секунди,\n * ніхто не встиг би роздивитись), поки вкладка у фоні і поки поточний\n * слайд — відео чи сторінка: обрізати відео на третій секунді гірше, ніж\n * зачекати. Файлове відео саме перегортає слайд, коли закінчиться.\n */\nfunction syncSlideshow() {\n  clearTimeout(slideshowTimer)\n  slideshowTimer = undefined\n  const kind = currentKind.value\n  const ready =\n    playing.value\n    && props.modelValue\n    && !documentHidden.value\n    && !zoomed.value\n    && (kind === 'image' || kind === 'custom')\n    && (currentLoaded.value || currentFailed.value)\n  slideshowTicking.value = ready\n  if (!ready) return\n  slideshowCycle.value += 1\n  slideshowTimer = setTimeout(advanceSlideshow, Math.max(1000, props.interval))\n}\n\nfunction advanceSlideshow() {\n  const target = nextSlideshowIndex(current.value, count.value, props.loop)\n  if (target === null) playing.value = false\n  else moveTo(target, 1)\n}\n\nwatch(\n  [playing, current, currentLoaded, currentFailed, zoomed, documentHidden, () => props.interval, () => props.modelValue],\n  syncSlideshow,\n)\n\nfunction toggleSlideshow() {\n  if (!slideshowAvailable.value) return\n  // Запуск на останньому кадрі без loop одразу б і зупинився.\n  if (!playing.value && atEnd.value) goTo(0)\n  playing.value = !playing.value\n}\n\nfunction onVideoEnded() {\n  if (playing.value) advanceSlideshow()\n}\n\nfunction onVisibilityChange() {\n  documentHidden.value = document.hidden\n}\n\nfunction toggleFullscreen() {\n  void fullscreen.toggle()\n}\n\nfunction toggleThumbnails() {\n  thumbnailsVisible.value = !thumbnailsVisible.value\n  if (thumbnailsVisible.value) scrollThumbIntoView(false)\n}\n\nconst downloadHref = computed(() => {\n  const item = image.value\n  const kind = currentKind.value\n  if (!item || item.download === false || (kind !== 'image' && kind !== 'video')) return null\n  return typeof item.download === 'string' ? item.download : item.src\n})\n\n/* ------------------------------------------------------------------ */\n/*  Анімація з мініатюри                                               */\n/* ------------------------------------------------------------------ */\n\n/** Клас на корені: фото летить саме, панель не згасає разом із ним. */\nconst zoomEffect = shallowRef(false)\n/** Фото ще вантажиться, а політ уже заплановано — заглушку не показуємо. */\nconst awaitingZoom = shallowRef(false)\nlet pendingZoomIn = 0\n\nfunction easingToken(name: `--${string}`, fallback: string): string {\n  if (typeof document === 'undefined') return fallback\n  return getComputedStyle(document.documentElement).getPropertyValue(name).trim() || fallback\n}\n\nfunction originFor(index: number): Element | null {\n  if (!props.origin) return null\n  let found: Element | null | undefined\n  try {\n    found = props.origin(index)\n  } catch {\n    found = null\n  }\n  if (!(found instanceof Element)) return null\n  return found instanceof HTMLImageElement ? found : found.querySelector('img') ?? found\n}\n\n/** Прямокутники, що обрізають елемент: вікно і предки з overflow. */\nfunction clipRects(element: Element): Rect[] {\n  const rects: Rect[] = [{ left: 0, top: 0, width: window.innerWidth, height: window.innerHeight }]\n  for (let node = element.parentElement; node && node !== document.body; node = node.parentElement) {\n    const style = getComputedStyle(node)\n    if (style.overflowX !== 'visible' || style.overflowY !== 'visible') rects.push(node.getBoundingClientRect())\n  }\n  return rects\n}\n\nfunction originInfo(index: number): { rect: Rect; fit: 'cover' | 'contain'; radius: number } | null {\n  const element = originFor(index)\n  if (!element) return null\n  const rect = element.getBoundingClientRect()\n  if (!rect.width || !rect.height || visibleFraction(rect, clipRects(element)) < 0.6) return null\n  const style = getComputedStyle(element)\n  const fit = element instanceof HTMLImageElement && style.objectFit !== 'cover' ? 'contain' : 'cover'\n  let radius = Number.parseFloat(style.borderTopLeftRadius) || 0\n  // Кути часто малює обгортка-кнопка з overflow-clip, а не саме зображення.\n  const parent = element.parentElement\n  if (parent) {\n    const outer = parent.getBoundingClientRect()\n    if (Math.abs(outer.width - rect.width) < 3 && Math.abs(outer.height - rect.height) < 3) {\n      radius = Math.max(radius, Number.parseFloat(getComputedStyle(parent).borderTopLeftRadius) || 0)\n    }\n  }\n  return { rect, fit, radius }\n}\n\n/** Де стоїть зображення без нашого transform: по центру своєї коробки. */\nfunction layoutRect(img: HTMLElement): Rect | null {\n  const box = img.parentElement\n  if (!box || !img.offsetWidth || !img.offsetHeight) return null\n  const outer = box.getBoundingClientRect()\n  return {\n    left: outer.left + (outer.width - img.offsetWidth) / 2,\n    top: outer.top + (outer.height - img.offsetHeight) / 2,\n    width: img.offsetWidth,\n    height: img.offsetHeight,\n  }\n}\n\nfunction canFlyFromOrigin(): boolean {\n  if (reducedMotion.value || !props.origin || currentKind.value !== 'image') return false\n  if (typeof HTMLElement === 'undefined' || typeof HTMLElement.prototype.animate !== 'function') return false\n  return !!originInfo(current.value)\n}\n\nfunction runZoomIn(): boolean {\n  const img = zoomEl()\n  const info = originInfo(current.value)\n  const layout = img && layoutRect(img)\n  if (!img || !info || !layout || typeof img.animate !== 'function') return false\n  const from = originTransform({ image: layout, thumbnail: info.rect, fit: info.fit, radius: info.radius })\n  img.animate(\n    [\n      {\n        transform: `translate3d(${from.x}px, ${from.y}px, 0) scale(${from.scale})`,\n        clipPath: `inset(${from.clipY}px ${from.clipX}px ${from.clipY}px ${from.clipX}px round ${from.radius}px)`,\n        opacity: 1,\n      },\n      { transform: transformString(), clipPath: 'inset(0px 0px 0px 0px round 0px)', opacity: 1 },\n    ],\n    { duration: readDurationToken('--duration-slow', 260), easing: easingToken('--ease-emphasized', 'cubic-bezier(0.32, 0.72, 0, 1)') },\n  )\n  return true\n}\n\n/*\n * Закриття: фото летить назад у мініатюру з того місця, де воно зараз, —\n * збільшене чи недотягнуте змахом. Повернуте чи віддзеркалене фото в\n * мініатюру не вляже, тож тоді галерея просто згасає.\n */\nfunction runZoomOut(): boolean {\n  if (reducedMotion.value || !props.origin || !canTransform.value) return false\n  if (rotation.value % 360 !== 0 || flipX.value < 0 || flipY.value < 0) return false\n  const img = zoomEl()\n  if (!img || typeof img.animate !== 'function') return false\n  const info = originInfo(current.value)\n  const layout = layoutRect(img)\n  if (!info || !layout) return false\n  stopInertia()\n  const to = originTransform({ image: layout, thumbnail: info.rect, fit: info.fit, radius: info.radius })\n  img.animate(\n    [\n      { transform: transformString(), clipPath: 'inset(0px 0px 0px 0px round 0px)' },\n      {\n        transform: `translate3d(${to.x}px, ${to.y}px, 0) scale(${to.scale})`,\n        clipPath: `inset(${to.clipY}px ${to.clipX}px ${to.clipY}px ${to.clipX}px round ${to.radius}px)`,\n      },\n    ],\n    { duration: readDurationToken('--duration-slow', 260), easing: easingToken('--ease-emphasized', 'cubic-bezier(0.32, 0.72, 0, 1)'), fill: 'forwards' },\n  )\n  return true\n}\n\n/* ------------------------------------------------------------------ */\n/*  Відкриття, фокус, клавіатура                                       */\n/* ------------------------------------------------------------------ */\n\nconst panelEl = ref<HTMLElement | null>(null)\nconst thumbEls = shallowRef<(HTMLElement | null)[]>([])\nconst teleportReady = shallowRef(false)\n/*\n * Escape — через спільний реєстр шарів, як у Modal і Drawer: він віддає\n * натиск рівно верхньому шару, тож підказка чи меню, відкриті поверх\n * галереї, закриються першими, а галерея — лише наступним Escape.\n */\nconst layer = useOverlayLayer(undefined, {\n  // Перший Escape лише зменшує: «вийти зі збільшення» і «закрити галерею» —\n  // різні наміри, і другий не має ховатися за першим.\n  onEscape: () => (zoomed.value ? resetZoom() : close()),\n})\nconst scrollLock = useScrollLock()\nconst focusTrap = useFocusTrap(() => panelEl.value)\nconst titleId = `${useId()}-lightbox`\n\n// Тривалості — з токенів руху, а не літерали: проєкт, що перевизначив\n// --duration-slow, інакше отримав би обрізану анімацію.\nconst transitionDuration = computed(() =>\n  reducedMotion.value\n    ? 0\n    : {\n        enter: readDurationToken('--duration-slow', 260),\n        leave: zoomEffect.value ? readDurationToken('--duration-slow', 260) : readDurationToken('--duration-base', 180),\n      },\n)\n\nfunction close() {\n  emit('update:modelValue', false)\n  emit('close')\n}\n\n/*\n * Фокус із слайда, що виїжджає, — на панель: слайд стане inert, і фокус\n * інакше впав би в <body>, де стрілки вже нічого не гортають.\n */\nfunction rescueFocus() {\n  const panel = panelEl.value\n  const active = typeof document === 'undefined' ? null : document.activeElement\n  if (panel && active instanceof HTMLElement && active.closest('[data-lightbox-slide]')) {\n    panel.focus({ preventScroll: true })\n  }\n}\n\nfunction clearTimers() {\n  clearTimeout(idleTimer)\n  clearTimeout(slideshowTimer)\n  clearTapTimer()\n  slideshowTimer = undefined\n}\n\nfunction resetForOpen() {\n  position.value = 0\n  outgoing.value = null\n  trackDrag = 0\n  view.scale = 1\n  view.x = 0\n  view.y = 0\n  closeOffset = 0\n  rotation.value = 0\n  flipX.value = 1\n  flipY.value = 1\n  zoomed.value = false\n  atMaxZoom.value = false\n  tapHidden.value = false\n  idleHidden.value = false\n  thumbnailsVisible.value = props.thumbnails\n  zoomEffect.value = false\n  awaitingZoom.value = false\n  pendingZoomIn = 0\n  playing.value = props.autoplay && !reducedMotion.value && count.value > 1\n}\n\nlet resizeObserver: ResizeObserver | null = null\nlet stageSize: Size = { width: 0, height: 0 }\n\n/*\n * Нова геометрія (поворот телефона, повний екран) — старі масштаб і зсув\n * можуть вивести фото за край. Вписуємо заново; поворот фото лишається.\n */\nfunction onStageResize() {\n  const stage = stageEl.value\n  if (!stage) return\n  const size = { width: stage.clientWidth, height: stage.clientHeight }\n  if (size.width === stageSize.width && size.height === stageSize.height) return\n  stageSize = size\n  stopInertia()\n  const geometry = measure()\n  view.scale = geometry?.base ?? 1\n  view.x = 0\n  view.y = 0\n  applyView('none', geometry)\n}\n\nfunction observeStage() {\n  disconnectStage()\n  const stage = stageEl.value\n  if (!stage) return\n  stageSize = { width: stage.clientWidth, height: stage.clientHeight }\n  if (typeof ResizeObserver !== 'undefined') {\n    resizeObserver = new ResizeObserver(onStageResize)\n    resizeObserver.observe(stage)\n  } else {\n    window.addEventListener('resize', onStageResize)\n  }\n}\n\nfunction disconnectStage() {\n  resizeObserver?.disconnect()\n  resizeObserver = null\n  if (typeof window !== 'undefined') window.removeEventListener('resize', onStageResize)\n}\n\n// handleClose кличе й onBeforeUnmount — у тому числі для галереї, яку не\n// відкривали: красти фокус на мініатюру тоді не можна.\nlet active = false\n\nasync function handleOpen() {\n  active = true\n  layer.activate()\n  scrollLock.lock()\n  resetForOpen()\n  await nextTick()\n  if (!props.modelValue) return\n  // Фокус на саму панель, а не на хрестик: стрілки мають гортати одразу,\n  // а перший Tab — дійти до першої кнопки, не пропустивши її.\n  focusTrap.activate({ initialFocus: null })\n  window.addEventListener('pointerup', onWindowPointerEnd, true)\n  window.addEventListener('pointercancel', onWindowPointerEnd, true)\n  observeStage()\n  applyTrack(false)\n  applyView('none')\n  scrollThumbIntoView(false)\n  scheduleIdle()\n\n  if (!zoomEffect.value) return\n  if (currentLoaded.value) {\n    runZoomIn()\n  } else {\n    // Фото ще в дорозі. Чекаємо його недовго: політ, що стартує через\n    // секунду після кліку, виглядає як збій, а не як анімація.\n    pendingZoomIn = performance.now() + 600\n    awaitingZoom.value = true\n  }\n}\n\n/*\n * З `origin` фокус повертається на мініатюру слайда, який переглядали, —\n * туди ж, куди летить фото. Кнопка, з якої галерею відкрили, часто вже\n * недосяжна: у каруселі, що йде за індексом галереї, її слайд став inert,\n * і фокус падав у <body>. Шукаємо фокусованого предка: мініатюра — це\n * зазвичай <img> усередині кнопки.\n */\nfunction returnFocusToOrigin() {\n  const origin = originFor(current.value)\n  const target = origin?.closest<HTMLElement>('a[href], button:not([disabled]), [tabindex]:not([tabindex=\"-1\"])')\n  if (!target || target.closest('[inert]') || !target.isConnected) return\n  target.focus({ preventScroll: true })\n}\n\nfunction handleClose() {\n  focusTrap.deactivate()\n  if (active) returnFocusToOrigin()\n  active = false\n  scrollLock.unlock()\n  layer.deactivate()\n  stopInertia()\n  clearTimers()\n  playing.value = false\n  pointers.clear()\n  endGesture()\n  if (typeof window !== 'undefined') {\n    window.removeEventListener('pointerup', onWindowPointerEnd, true)\n    window.removeEventListener('pointercancel', onWindowPointerEnd, true)\n  }\n  disconnectStage()\n  videoEl?.pause?.()\n  pendingZoomIn = 0\n  awaitingZoom.value = false\n  void fullscreen.exitIfEntered()\n}\n\nfunction onAfterLeave() {\n  layer.settle()\n  zoomEffect.value = false\n}\n\nlet planZoomIn = false\n\nwatch(\n  () => props.modelValue,\n  (open) => {\n    if (open) {\n      planZoomIn = true\n      void handleOpen()\n    } else {\n      // Спершу політ, поки фото ще на своєму місці, і лише потім розбір\n      // стану: після нього зникло б і те, звідки летіти.\n      zoomEffect.value = runZoomOut()\n      handleClose()\n    }\n  },\n)\n\n/*\n * Летіти чи ні — вирішуємо ДО того, як оверлей потрапить у DOM: тут усі\n * pre-watcher'и вже відпрацювали (індекс остаточний), а рендер ще попереду.\n * Пізніше не можна: вимірювання мініатюри примушує браузер перерахувати\n * стилі, і панель, вставлена без класу польоту, встигала почати звичайне\n * згасання — фото летіло напівпрозорим.\n */\nonBeforeUpdate(() => {\n  if (!planZoomIn) return\n  planZoomIn = false\n  zoomEffect.value = props.modelValue && canFlyFromOrigin()\n})\n\nfunction scrollThumbIntoView(smooth = true) {\n  void nextTick(() => {\n    thumbEls.value[current.value]?.scrollIntoView({\n      block: 'nearest',\n      inline: 'center',\n      behavior: smooth && !reducedMotion.value ? 'smooth' : 'auto',\n    })\n  })\n}\n\nwatch(current, () => {\n  if (!props.modelValue) return\n  const smooth = !instantStrip\n  instantStrip = false\n  scrollThumbIntoView(smooth)\n})\n\nconst PAN_STEP = 80\n\nfunction onKeydown(event: KeyboardEvent) {\n  // defaultPrevented — натиск уже обробив шар вище (меню, поле в панелі дій).\n  if (event.defaultPrevented || !props.modelValue || !layer.isTopmost.value) return\n  // Ціль — не обов'язково Element (подію можна диспатчити і на document).\n  const target = event.target\n  if (target instanceof Element && target.closest('input, textarea, select, video, audio, [contenteditable=\"true\"]')) return\n  wake()\n\n  const pan = zoomed.value\n  switch (event.key) {\n    case 'ArrowLeft':\n      if (pan) panBy(PAN_STEP, 0)\n      else previous()\n      break\n    case 'ArrowRight':\n      if (pan) panBy(-PAN_STEP, 0)\n      else next()\n      break\n    case 'ArrowUp':\n    case 'ArrowDown':\n      if (!pan) return\n      panBy(0, event.key === 'ArrowUp' ? PAN_STEP : -PAN_STEP)\n      break\n    case 'PageUp':\n      previous()\n      break\n    case 'PageDown':\n      next()\n      break\n    case 'Home':\n      if (pan) return\n      goTo(0)\n      break\n    case 'End':\n      if (pan) return\n      goTo(count.value - 1)\n      break\n    case '+':\n    case '=':\n      if (!canZoom.value) return\n      zoomIn()\n      break\n    case '-':\n    case '_':\n      if (!pan) return\n      zoomOut()\n      break\n    case '0':\n      if (!pan) return\n      resetZoom()\n      break\n    case ' ':\n      // Пробіл на кнопці — це натискання кнопки, а не слайдшоу.\n      if (!slideshowAvailable.value || (target instanceof Element && target.closest('button, a'))) return\n      toggleSlideshow()\n      break\n    default:\n      return\n  }\n  event.preventDefault()\n  event.stopPropagation()\n}\n\nonMounted(() => {\n  teleportReady.value = true\n  document.addEventListener('keydown', onKeydown)\n  document.addEventListener('visibilitychange', onVisibilityChange)\n  if (props.modelValue) void handleOpen()\n})\n\nonBeforeUnmount(() => {\n  document.removeEventListener('keydown', onKeydown)\n  document.removeEventListener('visibilitychange', onVisibilityChange)\n  handleClose()\n  clearTimeout(outgoingTimer)\n})\n\nconst announcement = computed(() => {\n  const item = image.value\n  return item ? text.value.slide(current.value + 1, count.value, item.alt, slideKindOf(currentKind.value)) : ''\n})\n\n/* ------------------------------------------------------------------ */\n/*  Класи шаблону                                                      */\n/* ------------------------------------------------------------------ */\n\nfunction panelStyle(panel: Panel) {\n  return props.transition === 'fade' ? undefined : { transform: `translate3d(${panel.vpos * 100}%, 0, 0)` }\n}\n\n// Схрещення: слайди один на одному, видно лише поточний.\nfunction panelClass(panel: Panel): string {\n  if (props.transition !== 'fade') return ''\n  return panel.offset === 0\n    ? 'opacity-100 transition-opacity duration-(--duration-slow)'\n    : 'opacity-0 transition-opacity duration-(--duration-slow)'\n}\n\nfunction imageClass(panel: Panel): string {\n  if (stateOf(panel.item) !== 'loaded') return 'opacity-0'\n  // Заглушка вже стоїть на тому самому місці — фото підміняє її миттєво,\n  // згасання показало б між ними порожній фон. Під час польоту з мініатюри\n  // фото теж не згасає: воно вже непрозоре там, звідки летить.\n  const instant = (panel.item.thumbnail && panel.item.thumbnail !== panel.item.src) || (zoomEffect.value && panel.offset === 0)\n  const appear = instant ? '' : 'ui-lightbox-appear'\n  if (panel.offset !== 0) return appear\n  const cursor = zoomed.value ? (grabbing.value ? 'cursor-grabbing' : 'cursor-grab') : canZoom.value ? 'cursor-zoom-in' : ''\n  return `${appear} ${cursor}`\n}\n\nconst chromeClass = computed(() => (chromeHidden.value ? 'ui-lightbox-chrome pointer-events-none' : 'ui-lightbox-chrome'))\n\n/*\n * Кнопки поверх фото — кола з поверхнею картки й blur, як стрілки\n * UiCarousel: читаються на будь-якому зображенні й у будь-якій темі.\n * Позиція й display — окремо на кожному місці: `relative`/`absolute` чи\n * `flex`/`hidden` в одному рядку класів вирішував би порядок CSS, а не\n * шаблон.\n */\nconst chromeButton =\n  'h-10 w-10 shrink-0 items-center justify-center rounded-full border border-line bg-card/85 text-ink shadow-card backdrop-blur-sm transition-colors hover:bg-card active:bg-hover focus:outline-none focus-visible:ring-2 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-40 md:h-9 md:w-9 ' +\n  \"pointer-coarse:after:absolute pointer-coarse:after:top-1/2 pointer-coarse:after:left-1/2 pointer-coarse:after:h-12 pointer-coarse:after:w-12 pointer-coarse:after:-translate-x-1/2 pointer-coarse:after:-translate-y-1/2 pointer-coarse:after:content-['']\"\n\ndefineExpose({\n  previous,\n  next,\n  goTo,\n  zoomIn: () => zoomIn(),\n  zoomOut: () => zoomOut(),\n  resetZoom,\n  toggleZoom: () => toggleZoom(),\n  rotate,\n  flip,\n  toggleSlideshow,\n  toggleFullscreen,\n})\n</script>\n\n<template>\n  <Teleport to=\"body\" :disabled=\"!teleportReady\">\n    <Transition name=\"ui-lightbox\" :duration=\"transitionDuration\" @after-leave=\"onAfterLeave\">\n      <div\n        v-if=\"modelValue\"\n        ref=\"rootEl\"\n        data-ui-overlay\n        class=\"fixed inset-0\"\n        :class=\"[zoomEffect ? 'ui-lightbox-zoom' : '', closeDragging ? 'ui-lightbox-dragging' : '']\"\n        :style=\"{ zIndex: layer.zIndex.value, '--ui-lightbox-chrome': chromeHidden ? 0 : 1 }\"\n      >\n        <!-- Фон — майже чорний в обох темах: фото читається на темному, а\n             кнопки й підписи несуть власну поверхню картки. 95%, а не 90:\n             при 90 текст сторінки проступав крізь фон і сперечався з фото.\n             Сторінку видно, коли фон гасне під змахом для закриття. -->\n        <div class=\"ui-lightbox-backdrop absolute inset-0 bg-backdrop/95\" aria-hidden=\"true\" />\n\n        <div\n          ref=\"panelEl\"\n          role=\"dialog\"\n          aria-modal=\"true\"\n          :aria-label=\"uiText(ariaLabel)\"\n          :aria-describedby=\"image ? titleId : undefined\"\n          tabindex=\"-1\"\n          class=\"ui-lightbox-panel relative flex h-full flex-col outline-none\"\n          @pointermove=\"onPanelPointerMove\"\n          @focusin=\"onPanelFocusIn\"\n        >\n          <!-- Під час слайдшоу кадри змінюються самі — оголошувати кожен\n               означало б говорити без упину (як autoplay у UiCarousel). -->\n          <span :id=\"titleId\" class=\"sr-only\" :aria-live=\"playing ? 'off' : 'polite'\">{{ announcement }}</span>\n\n          <div\n            v-if=\"playing && slideshowTicking\"\n            :key=\"slideshowCycle\"\n            class=\"ui-lightbox-progress pointer-events-none absolute inset-x-0 top-[env(safe-area-inset-top)] z-20 h-0.5 bg-accent-solid motion-reduce:hidden\"\n            :style=\"{ animationDuration: `${Math.max(1000, interval)}ms` }\"\n            aria-hidden=\"true\"\n          />\n\n          <!-- Верхня панель: лічильник, дії, інструменти, хрестик. Відступи\n               з безпечними зонами окремо з кожного боку: у ландшафті\n               iPhone виріз камери стоїть збоку, а не згори. -->\n          <div\n            class=\"flex shrink-0 items-center gap-2 pt-[max(0.75rem,env(safe-area-inset-top))] pb-3 ps-[max(0.75rem,env(safe-area-inset-left))] pe-[max(0.75rem,env(safe-area-inset-right))]\"\n            :class=\"chromeClass\"\n            data-lightbox-chrome\n            @pointerenter=\"onChromePointer(true)\"\n            @pointerleave=\"onChromePointer(false)\"\n          >\n            <span\n              v-if=\"count > 1\"\n              class=\"shrink-0 rounded-full border border-line bg-card/85 px-3 py-1.5 text-sm font-medium tabular-nums text-ink shadow-card backdrop-blur-sm\"\n              aria-hidden=\"true\"\n            >\n              {{ current + 1 }} / {{ count }}\n            </span>\n\n            <div class=\"ms-auto flex min-w-0 items-center gap-2\">\n              <!-- Прокрутка, а не перенос: на вузькому телефоні з повним\n                   набором інструментів кнопки не мають наповзати на\n                   лічильник чи ламати висоту панелі. p-1 — місце для\n                   фокус-кільця, яке overflow інакше обрізав би, а\n                   scroll-px-1 — той самий відступ, коли фокус докручує\n                   кнопку (onStripFocusIn). -->\n              <div\n                class=\"scrollbar-none -m-1 flex min-w-0 items-center gap-2 overflow-x-auto p-1 scroll-px-1\"\n                @focusin=\"onStripFocusIn\"\n              >\n                <slot v-if=\"image\" name=\"actions\" :image=\"image\" :index=\"current\" />\n\n                <template v-for=\"tool in toolbarItems\" :key=\"tool\">\n                  <button\n                    v-if=\"tool === 'zoom'\"\n                    type=\"button\"\n                    class=\"relative flex\"\n                    :class=\"chromeButton\"\n                    :disabled=\"!canZoom\"\n                    :aria-label=\"zoomed ? text.zoomOut : text.zoomIn\"\n                    @click=\"toggleZoom()\"\n                  >\n                    <svg class=\"h-5 w-5\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" aria-hidden=\"true\">\n                      <circle cx=\"11\" cy=\"11\" r=\"6.5\" />\n                      <path d=\"m20 20-4.2-4.2M8.5 11h5\" />\n                      <path v-if=\"!zoomed\" d=\"M11 8.5v5\" />\n                    </svg>\n                  </button>\n\n                  <button\n                    v-else-if=\"tool === 'zoomIn'\"\n                    type=\"button\"\n                    class=\"relative flex\"\n                    :class=\"chromeButton\"\n                    :disabled=\"!canZoom || atMaxZoom\"\n                    :aria-label=\"text.zoomIn\"\n                    @click=\"zoomIn()\"\n                  >\n                    <svg class=\"h-5 w-5\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" aria-hidden=\"true\">\n                      <circle cx=\"11\" cy=\"11\" r=\"6.5\" />\n                      <path d=\"m20 20-4.2-4.2M8.5 11h5M11 8.5v5\" />\n                    </svg>\n                  </button>\n\n                  <button\n                    v-else-if=\"tool === 'zoomOut'\"\n                    type=\"button\"\n                    class=\"relative flex\"\n                    :class=\"chromeButton\"\n                    :disabled=\"!canZoom || !zoomed\"\n                    :aria-label=\"text.zoomOut\"\n                    @click=\"zoomOut()\"\n                  >\n                    <svg class=\"h-5 w-5\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" aria-hidden=\"true\">\n                      <circle cx=\"11\" cy=\"11\" r=\"6.5\" />\n                      <path d=\"m20 20-4.2-4.2M8.5 11h5\" />\n                    </svg>\n                  </button>\n\n                  <template v-else-if=\"tool === 'rotate'\">\n                    <button type=\"button\" class=\"relative flex\" :class=\"chromeButton\" :disabled=\"!canTransform\" :aria-label=\"text.rotateLeft\" @click=\"rotate(-1)\">\n                      <svg class=\"h-5 w-5\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" aria-hidden=\"true\">\n                        <path d=\"M4 12a8 8 0 1 0 2.35-5.65L4 8.7\" />\n                        <path d=\"M4 4.2v4.5h4.5\" />\n                      </svg>\n                    </button>\n                    <button type=\"button\" class=\"relative flex\" :class=\"chromeButton\" :disabled=\"!canTransform\" :aria-label=\"text.rotateRight\" @click=\"rotate(1)\">\n                      <svg class=\"h-5 w-5\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" aria-hidden=\"true\">\n                        <path d=\"M20 12a8 8 0 1 1-2.35-5.65L20 8.7\" />\n                        <path d=\"M20 4.2v4.5h-4.5\" />\n                      </svg>\n                    </button>\n                  </template>\n\n                  <template v-else-if=\"tool === 'flip'\">\n                    <button type=\"button\" class=\"relative flex\" :class=\"chromeButton\" :disabled=\"!canTransform\" :aria-label=\"text.flipHorizontal\" @click=\"flip('x')\">\n                      <svg class=\"h-5 w-5\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" aria-hidden=\"true\">\n                        <path d=\"M12 3.5v17\" stroke-dasharray=\"2 2.5\" />\n                        <path d=\"M8.5 7 3.5 17h5z\" />\n                        <path d=\"M15.5 7l5 10h-5z\" />\n                      </svg>\n                    </button>\n                    <button type=\"button\" class=\"relative flex\" :class=\"chromeButton\" :disabled=\"!canTransform\" :aria-label=\"text.flipVertical\" @click=\"flip('y')\">\n                      <svg class=\"h-5 w-5\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" aria-hidden=\"true\">\n                        <path d=\"M3.5 12h17\" stroke-dasharray=\"2 2.5\" />\n                        <path d=\"M7 8.5 17 3.5v5z\" />\n                        <path d=\"M7 15.5l10 5v-5z\" />\n                      </svg>\n                    </button>\n                  </template>\n\n                  <button\n                    v-else-if=\"tool === 'slideshow'\"\n                    type=\"button\"\n                    class=\"relative flex\"\n                    :class=\"chromeButton\"\n                    :disabled=\"count < 2\"\n                    :aria-label=\"playing ? text.slideshowPause : text.slideshowPlay\"\n                    @click=\"toggleSlideshow\"\n                  >\n                    <svg v-if=\"playing\" class=\"h-5 w-5\" viewBox=\"0 0 24 24\" fill=\"none\" aria-hidden=\"true\">\n                      <path d=\"M9 6v12M15 6v12\" stroke=\"currentColor\" stroke-width=\"2.5\" stroke-linecap=\"round\" />\n                    </svg>\n                    <svg v-else class=\"h-5 w-5\" viewBox=\"0 0 24 24\" fill=\"currentColor\" aria-hidden=\"true\">\n                      <path d=\"M8.5 5.8v12.4a.8.8 0 0 0 1.2.7l10-6.2a.8.8 0 0 0 0-1.4l-10-6.2a.8.8 0 0 0-1.2.7z\" />\n                    </svg>\n                  </button>\n\n                  <button\n                    v-else-if=\"tool === 'fullscreen'\"\n                    type=\"button\"\n                    class=\"relative flex\"\n                    :class=\"chromeButton\"\n                    :aria-label=\"fullscreen.active.value ? text.fullscreenExit : text.fullscreenEnter\"\n                    @click=\"toggleFullscreen\"\n                  >\n                    <svg class=\"h-5 w-5\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" aria-hidden=\"true\">\n                      <path v-if=\"fullscreen.active.value\" d=\"M9 4v5H4M15 4v5h5M9 20v-5H4M15 20v-5h5\" />\n                      <path v-else d=\"M4 9V4h5M20 9V4h-5M4 15v5h5M20 15v5h-5\" />\n                    </svg>\n                  </button>\n\n                  <button\n                    v-else-if=\"tool === 'thumbnails'\"\n                    type=\"button\"\n                    class=\"relative flex\"\n                    :class=\"chromeButton\"\n                    :aria-label=\"thumbnailsVisible ? text.thumbnailsHide : text.thumbnailsShow\"\n                    @click=\"toggleThumbnails\"\n                  >\n                    <svg class=\"h-5 w-5\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linejoin=\"round\" aria-hidden=\"true\">\n                      <rect x=\"4\" y=\"4\" width=\"6.5\" height=\"6.5\" rx=\"1.5\" />\n                      <rect x=\"13.5\" y=\"4\" width=\"6.5\" height=\"6.5\" rx=\"1.5\" />\n                      <rect x=\"4\" y=\"13.5\" width=\"6.5\" height=\"6.5\" rx=\"1.5\" />\n                      <rect x=\"13.5\" y=\"13.5\" width=\"6.5\" height=\"6.5\" rx=\"1.5\" />\n                    </svg>\n                  </button>\n\n                  <template v-else-if=\"tool === 'download'\">\n                    <!-- target=\"_blank\": атрибут download працює лише для\n                         свого домену, і чуже фото інакше відкрилося б\n                         замість галереї в тій самій вкладці. -->\n                    <a\n                      v-if=\"downloadHref\"\n                      :href=\"downloadHref\"\n                      download\n                      target=\"_blank\"\n                      rel=\"noopener\"\n                      class=\"relative flex\"\n                      :class=\"chromeButton\"\n                      :aria-label=\"text.download\"\n                    >\n                      <svg class=\"h-5 w-5\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" aria-hidden=\"true\">\n                        <path d=\"M12 4v11M7.5 10.5 12 15l4.5-4.5M5 19.5h14\" />\n                      </svg>\n                    </a>\n                    <button v-else type=\"button\" class=\"relative flex\" :class=\"chromeButton\" disabled :aria-label=\"text.download\">\n                      <svg class=\"h-5 w-5\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" aria-hidden=\"true\">\n                        <path d=\"M12 4v11M7.5 10.5 12 15l4.5-4.5M5 19.5h14\" />\n                      </svg>\n                    </button>\n                  </template>\n                </template>\n              </div>\n\n              <button type=\"button\" class=\"relative flex\" :class=\"chromeButton\" :aria-label=\"text.close\" @click=\"close\">\n                <svg class=\"h-5 w-5\" viewBox=\"0 0 24 24\" fill=\"none\" aria-hidden=\"true\">\n                  <path d=\"M18 6 6 18M6 6l12 12\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" />\n                </svg>\n              </button>\n            </div>\n          </div>\n\n          <!--\n            Сцена. touch-none: усі жести тут наші — свайп, змах для\n            закриття, щипок, зсув збільшеного фото. overflow-clip, а не\n            hidden: у hidden-контейнері фокус на елементі сусіднього слайда\n            міг би прокрутити сцену й зсунути трек.\n          -->\n          <div\n            ref=\"stageEl\"\n            class=\"relative min-h-0 flex-1 touch-none overflow-clip\"\n            :class=\"grabbing ? 'select-none' : ''\"\n            data-lightbox-backdrop\n            @pointerdown=\"onPointerDown\"\n            @pointermove=\"onPointerMove\"\n            @click=\"onStageClick\"\n            @wheel=\"onWheel\"\n          >\n            <div ref=\"trackEl\" class=\"absolute inset-0\" data-lightbox-backdrop>\n              <div\n                v-for=\"panel in panels\"\n                :key=\"panel.vpos\"\n                class=\"absolute inset-0 flex px-2 sm:px-16\"\n                :class=\"panelClass(panel)\"\n                :style=\"panelStyle(panel)\"\n                :inert=\"panel.offset !== 0\"\n                :aria-hidden=\"panel.offset !== 0 ? 'true' : undefined\"\n                data-lightbox-slide\n                data-lightbox-backdrop\n              >\n                <div\n                  :ref=\"(element) => setBoxEl(panel.vpos, element)\"\n                  class=\"relative flex h-full w-full min-w-0\"\n                  :class=\"panel.kind === 'iframe' || panel.kind === 'youtube' || panel.kind === 'vimeo' ? '[container-type:size]' : ''\"\n                  data-lightbox-backdrop\n                >\n                  <template v-if=\"panel.kind === 'image'\">\n                    <!-- Заглушка — мініатюра, розтягнута рівно туди, де стане\n                         фото: max-розміри з width/height не дають їй вийти\n                         за натуральний розмір, як не виходить і саме фото. -->\n                    <img\n                      v-if=\"placeholderFor(panel)\"\n                      :src=\"placeholderFor(panel) ?? undefined\"\n                      alt=\"\"\n                      aria-hidden=\"true\"\n                      draggable=\"false\"\n                      class=\"absolute inset-0 m-auto h-full w-full object-contain\"\n                      :style=\"naturalBox(panel.item)\"\n                    />\n                    <img\n                      :key=\"`${panel.item.src}#${retries[panel.item.src] ?? 0}`\"\n                      :ref=\"(element) => setImgEl(panel, element)\"\n                      :src=\"panel.item.src\"\n                      :srcset=\"panel.item.srcset\"\n                      :sizes=\"panel.item.srcset ? panel.item.sizes ?? '100vw' : undefined\"\n                      :alt=\"panel.item.alt\"\n                      draggable=\"false\"\n                      decoding=\"async\"\n                      :fetchpriority=\"panel.offset === 0 ? 'high' : 'low'\"\n                      class=\"relative m-auto block max-h-full max-w-full object-contain\"\n                      :class=\"imageClass(panel)\"\n                      @load=\"onImageLoad(panel)\"\n                      @error=\"markFailed(panel.item)\"\n                    />\n                  </template>\n\n                  <template v-else-if=\"panel.kind === 'video'\">\n                    <video\n                      v-if=\"panel.offset === 0\"\n                      :ref=\"setVideoEl\"\n                      :src=\"panel.item.src\"\n                      :poster=\"panel.item.poster\"\n                      :aria-label=\"panel.item.alt\"\n                      controls\n                      playsinline\n                      preload=\"metadata\"\n                      class=\"relative m-auto block max-h-full max-w-full\"\n                      @loadeddata=\"markLoaded(panel.item)\"\n                      @error=\"markFailed(panel.item)\"\n                      @ended=\"onVideoEnded\"\n                    />\n                    <img\n                      v-else-if=\"posterFor(panel.item, panel.kind)\"\n                      :src=\"posterFor(panel.item, panel.kind) ?? undefined\"\n                      alt=\"\"\n                      draggable=\"false\"\n                      class=\"m-auto block max-h-full max-w-full object-contain\"\n                    />\n                  </template>\n\n                  <div v-else-if=\"panel.kind === 'custom'\" class=\"m-auto max-h-full max-w-full overflow-auto overscroll-contain\" data-lightbox-custom>\n                    <slot name=\"custom\" :image=\"panel.item\" :index=\"panel.index\" :active=\"panel.offset === 0\" />\n                  </div>\n\n                  <template v-else>\n                    <!-- Плеєр вбудовується лише для поточного слайда: сусід\n                         із YouTube, змонтований заздалегідь, почав би грати\n                         за кадром, а зайвий iframe — це ще й чужі cookies. -->\n                    <iframe\n                      v-if=\"panel.offset === 0\"\n                      :src=\"embedSrc(panel.kind, panel.item.src)\"\n                      :title=\"panel.item.alt\"\n                      allow=\"autoplay; fullscreen; picture-in-picture; encrypted-media\"\n                      referrerpolicy=\"strict-origin-when-cross-origin\"\n                      class=\"relative m-auto block rounded-card border-0 bg-backdrop\"\n                      :style=\"frameStyle(panel)\"\n                      @load=\"markLoaded(panel.item)\"\n                    />\n                    <img\n                      v-else-if=\"posterFor(panel.item, panel.kind)\"\n                      :src=\"posterFor(panel.item, panel.kind) ?? undefined\"\n                      alt=\"\"\n                      draggable=\"false\"\n                      class=\"m-auto block max-h-full max-w-full object-contain\"\n                    />\n                  </template>\n                </div>\n              </div>\n            </div>\n\n            <div\n              v-if=\"image && !currentLoaded && !currentFailed\"\n              class=\"pointer-events-none absolute inset-0 z-10 flex items-center justify-center\"\n            >\n              <span class=\"rounded-full border border-line bg-card/85 p-3 shadow-card backdrop-blur-sm\">\n                <UiSpinner size=\"lg\" tone=\"accent\" :label=\"text.loading\" />\n              </span>\n            </div>\n\n            <div\n              v-if=\"!image || currentFailed\"\n              class=\"pointer-events-none absolute inset-0 z-10 flex items-center justify-center p-6\"\n            >\n              <div class=\"pointer-events-auto flex flex-col items-center gap-3 rounded-card border border-line bg-card/90 px-4 py-3 text-sm text-ink shadow-card\">\n                <p role=\"alert\">{{ image ? text.error : text.empty }}</p>\n                <button\n                  v-if=\"image\"\n                  type=\"button\"\n                  class=\"h-10 rounded-control border border-line bg-card px-3 font-medium text-ink transition-colors hover:bg-hover focus:outline-none focus-visible:ring-2 focus-visible:ring-ring md:h-9\"\n                  @click=\"retry\"\n                >\n                  {{ text.retry }}\n                </button>\n              </div>\n            </div>\n\n            <!-- Стрілки лише від sm: на телефоні основний жест — свайп, а\n                 кнопки поверх фото закривали б його край, як у UiCarousel. -->\n            <template v-if=\"count > 1 && !zoomed\">\n              <button\n                type=\"button\"\n                :class=\"[chromeButton, chromeClass]\"\n                class=\"absolute left-[max(0.75rem,env(safe-area-inset-left))] top-1/2 z-10 hidden -translate-y-1/2 sm:flex\"\n                :disabled=\"atStart\"\n                :aria-label=\"text.previous\"\n                data-lightbox-chrome\n                @click=\"previous\"\n              >\n                <svg class=\"h-5 w-5\" viewBox=\"0 0 24 24\" fill=\"none\" aria-hidden=\"true\">\n                  <path d=\"M15 18l-6-6 6-6\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\n                </svg>\n              </button>\n              <button\n                type=\"button\"\n                :class=\"[chromeButton, chromeClass]\"\n                class=\"absolute right-[max(0.75rem,env(safe-area-inset-right))] top-1/2 z-10 hidden -translate-y-1/2 sm:flex\"\n                :disabled=\"atEnd\"\n                :aria-label=\"text.next\"\n                data-lightbox-chrome\n                @click=\"next\"\n              >\n                <svg class=\"h-5 w-5\" viewBox=\"0 0 24 24\" fill=\"none\" aria-hidden=\"true\">\n                  <path d=\"M9 6l6 6-6 6\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\n                </svg>\n              </button>\n            </template>\n          </div>\n\n          <div\n            v-if=\"image && ($slots.caption || image.caption)\"\n            class=\"flex shrink-0 justify-center px-4 pt-3\"\n            :class=\"chromeClass\"\n            data-lightbox-chrome\n          >\n            <div class=\"max-h-[25vh] max-w-2xl overflow-y-auto overscroll-contain rounded-card border border-line bg-card/85 px-3 py-2 text-center text-sm text-ink shadow-card backdrop-blur-sm\">\n              <slot name=\"caption\" :image=\"image\" :index=\"current\">{{ image.caption }}</slot>\n            </div>\n          </div>\n\n          <!--\n            Стрічка мініатюр: w-fit + mx-auto, а не justify-center на\n            контейнері з прокруткою — інакше при переповненні ліві мініатюри\n            опиняються за лівим краєм, куди прокрутка вже не дістає.\n            scroll-px-4 — той самий відступ від краю, коли Tab докручує\n            мініатюру (onStripFocusIn).\n          -->\n          <div\n            v-if=\"showThumbnails\"\n            class=\"shrink-0 pt-3 pb-[max(1rem,env(safe-area-inset-bottom))]\"\n            :class=\"chromeClass\"\n            data-lightbox-chrome\n            @pointerenter=\"onChromePointer(true)\"\n            @pointerleave=\"onChromePointer(false)\"\n          >\n            <div\n              class=\"scrollbar-none mx-auto flex w-fit max-w-full gap-2 overflow-x-auto px-4 py-1 scroll-px-4\"\n              role=\"group\"\n              :aria-label=\"text.thumbnails\"\n              @focusin=\"onStripFocusIn\"\n            >\n              <button\n                v-for=\"(item, index) in images\"\n                :key=\"thumbKeys[index]\"\n                :ref=\"(element) => (thumbEls[index] = element as HTMLElement | null)\"\n                type=\"button\"\n                class=\"relative h-14 w-14 shrink-0 overflow-clip rounded-control border-2 bg-card transition-[border-color,opacity] focus:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-backdrop\"\n                :class=\"index === current ? 'border-accent-solid opacity-100' : 'border-transparent opacity-60 hover:opacity-100'\"\n                :aria-label=\"text.thumbnail(index + 1, item.alt, slideKindOf(kindAt(index)))\"\n                :aria-current=\"index === current ? 'true' : undefined\"\n                @click=\"goTo(index)\"\n              >\n                <img\n                  v-if=\"thumbnailFor(item, index)\"\n                  :src=\"thumbnailFor(item, index) ?? undefined\"\n                  alt=\"\"\n                  loading=\"lazy\"\n                  decoding=\"async\"\n                  draggable=\"false\"\n                  class=\"h-full w-full object-cover\"\n                />\n                <span v-else class=\"flex h-full w-full items-center justify-center text-muted\" aria-hidden=\"true\">\n                  <svg class=\"h-6 w-6\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.8\" stroke-linejoin=\"round\">\n                    <rect x=\"3.5\" y=\"5\" width=\"17\" height=\"14\" rx=\"2\" />\n                    <path d=\"M3.5 9h17\" />\n                  </svg>\n                </span>\n                <!-- Відео в стрічці впізнається за значком «відтворити». -->\n                <span\n                  v-if=\"slideKindOf(kindAt(index)) === 'video'\"\n                  class=\"absolute inset-0 flex items-center justify-center\"\n                  aria-hidden=\"true\"\n                >\n                  <span class=\"flex h-6 w-6 items-center justify-center rounded-full bg-card/85 text-ink shadow-card\">\n                    <svg class=\"ms-0.5 h-3 w-3\" viewBox=\"0 0 24 24\" fill=\"currentColor\">\n                      <path d=\"M7 4.5v15l13-7.5z\" />\n                    </svg>\n                  </span>\n                </span>\n              </button>\n            </div>\n          </div>\n          <div v-else class=\"shrink-0 pb-[max(0.75rem,env(safe-area-inset-bottom))]\" />\n        </div>\n      </div>\n    </Transition>\n  </Teleport>\n</template>\n\n<style scoped>\n/*\n * Фон і панелі гаснуть під час змаху для закриття через --ui-lightbox-fade\n * (JS пише її на корінь), а ховаються без руху миші чи дотиком — через\n * --ui-lightbox-chrome (реактивний стиль). Змінні, а не інлайнова opacity:\n * класи входу й виходу нижче мають її перебивати.\n */\n.ui-lightbox-backdrop {\n  opacity: var(--ui-lightbox-fade, 1);\n  transition: opacity var(--duration-base) var(--ease-out);\n}\n\n.ui-lightbox-chrome {\n  opacity: calc(var(--ui-lightbox-chrome, 1) * var(--ui-lightbox-fade, 1));\n  transition: opacity var(--duration-base) var(--ease-out);\n}\n\n/* Під пальцем фон гасне синхронно з рухом, без запізнення переходу. */\n.ui-lightbox-dragging .ui-lightbox-backdrop,\n.ui-lightbox-dragging .ui-lightbox-chrome {\n  transition: none;\n}\n\n.ui-lightbox-appear {\n  animation: ui-lightbox-appear var(--duration-base) var(--ease-out);\n}\n\n@keyframes ui-lightbox-appear {\n  from {\n    opacity: 0;\n  }\n}\n\n.ui-lightbox-progress {\n  transform-origin: left center;\n  animation: ui-lightbox-progress linear forwards;\n}\n\n@keyframes ui-lightbox-progress {\n  from {\n    transform: scaleX(0);\n  }\n  to {\n    transform: scaleX(1);\n  }\n}\n\n.ui-lightbox-enter-active .ui-lightbox-backdrop,\n.ui-lightbox-leave-active .ui-lightbox-backdrop {\n  transition: opacity var(--duration-slow) var(--ease-out);\n}\n\n.ui-lightbox-enter-from .ui-lightbox-backdrop,\n.ui-lightbox-leave-to .ui-lightbox-backdrop {\n  opacity: 0;\n}\n\n.ui-lightbox-enter-active .ui-lightbox-panel {\n  transition:\n    opacity var(--duration-slow) var(--ease-out),\n    transform var(--duration-slow) var(--ease-emphasized);\n}\n\n.ui-lightbox-leave-active .ui-lightbox-panel {\n  transition:\n    opacity var(--duration-base) var(--ease-in),\n    transform var(--duration-base) var(--ease-in);\n}\n\n.ui-lightbox-enter-from .ui-lightbox-panel,\n.ui-lightbox-leave-to .ui-lightbox-panel {\n  opacity: 0;\n  transform: scale(0.97);\n}\n\n/*\n * Політ із мініатюри: фото анімується саме (Web Animations), тож панель\n * не згасає й не стискається разом із ним — гаснуть лише панелі\n * інструментів і фон.\n */\n.ui-lightbox-zoom.ui-lightbox-enter-from .ui-lightbox-panel,\n.ui-lightbox-zoom.ui-lightbox-leave-to .ui-lightbox-panel {\n  opacity: 1;\n  transform: none;\n}\n\n.ui-lightbox-zoom.ui-lightbox-enter-active .ui-lightbox-chrome,\n.ui-lightbox-zoom.ui-lightbox-leave-active .ui-lightbox-chrome {\n  transition: opacity var(--duration-slow) var(--ease-out);\n}\n\n.ui-lightbox-zoom.ui-lightbox-enter-from .ui-lightbox-chrome,\n.ui-lightbox-zoom.ui-lightbox-leave-to .ui-lightbox-chrome {\n  opacity: 0;\n}\n\n@media (prefers-reduced-motion: reduce) {\n  .ui-lightbox-enter-from .ui-lightbox-panel,\n  .ui-lightbox-leave-to .ui-lightbox-panel {\n    transform: none;\n  }\n}\n</style>\n"
    },
    {
      "path": "app/components/ui/UiSpinner.vue",
      "url": "/registry/source/app/components/ui/UiSpinner.vue.txt",
      "sha256": "1627af8eb5630ac6e270fe49269175ed658a428df82f733c26c6c02ebff0272c",
      "content": "<script setup lang=\"ts\">\nimport { computed } from 'vue'\n\nconst props = withDefaults(\n  defineProps<{\n    /**\n     * Діаметр. `xs`/`sm` — усередині рядка тексту, кнопки чи комірки\n     * таблиці; `md` — у картці; `lg` — на місці вмісту панелі.\n     */\n    size?: 'xs' | 'sm' | 'md' | 'lg'\n    /**\n     * Колір. `current` успадковує колір тексту батька — усередині суцільної\n     * кнопки спінер сам стає білим, у приглушеному рядку — приглушеним.\n     */\n    tone?: 'current' | 'accent' | 'muted'\n    /**\n     * Що саме вантажиться: «Завантаження замовлень». Із ним спінер стає\n     * `role=\"status\"`; без нього — декоративний (`aria-hidden`), і стан\n     * має оголошувати контейнер (`aria-busy`) або текст поруч.\n     */\n    label?: string\n    /** Показати `label` видимим текстом праворуч від кола. */\n    showLabel?: boolean\n  }>(),\n  { size: 'sm', tone: 'current', label: undefined, showLabel: false },\n)\n\ndefineSlots<Record<string, never>>()\n\ntype Size = NonNullable<typeof props.size>\ntype Tone = NonNullable<typeof props.tone>\n\nconst SIZES: Record<Size, string> = {\n  xs: 'h-3 w-3',\n  sm: 'h-4 w-4',\n  md: 'h-5 w-5',\n  lg: 'h-8 w-8',\n}\n\nconst TONES: Record<Tone, string> = {\n  current: 'text-current',\n  accent: 'text-accent',\n  muted: 'text-muted',\n}\n\nconst LABEL_SIZES: Record<Size, string> = {\n  xs: 'text-xs',\n  sm: 'text-sm',\n  md: 'text-sm',\n  lg: 'text-base',\n}\n\nconst announced = computed(() => !!props.label)\n</script>\n\n<template>\n  <!--\n    role=\"status\" — лише коли є що оголосити. Спінер без назви зі статусною\n    роллю скрінрідер зачитує як «статус» і нічого більше: шум без змісту.\n  -->\n  <span\n    class=\"inline-flex shrink-0 items-center gap-2 align-middle\"\n    :class=\"TONES[tone]\"\n    :role=\"announced ? 'status' : undefined\"\n    :aria-hidden=\"announced ? undefined : 'true'\"\n  >\n    <!--\n      pathLength=\"100\" — довжини дуги задаються відсотками кола, а не\n      2πr: однаковий рисунок за будь-якого розміру й товщини.\n    -->\n    <svg\n      class=\"ui-spinner shrink-0\"\n      :class=\"SIZES[size]\"\n      viewBox=\"0 0 24 24\"\n      fill=\"none\"\n      aria-hidden=\"true\"\n    >\n      <circle cx=\"12\" cy=\"12\" r=\"9\" stroke=\"currentColor\" stroke-width=\"2.5\" opacity=\"0.2\" />\n      <circle\n        class=\"ui-spinner-arc\"\n        cx=\"12\"\n        cy=\"12\"\n        r=\"9\"\n        stroke=\"currentColor\"\n        stroke-width=\"2.5\"\n        stroke-linecap=\"round\"\n        pathLength=\"100\"\n        stroke-dasharray=\"30 100\"\n      />\n    </svg>\n    <span v-if=\"label\" :class=\"showLabel ? ['text-muted', LABEL_SIZES[size]] : 'sr-only'\">{{ label }}</span>\n  </span>\n</template>\n\n<style scoped>\n/*\n * Обертається вся SVG, а не дуга: transform на <circle> у Safari рахує\n * origin від вьюпорта SVG, і дуга «гуляла» б по колу замість обертання.\n */\n.ui-spinner {\n  animation: ui-spinner-rotate 0.8s linear infinite;\n}\n\n@keyframes ui-spinner-rotate {\n  to {\n    transform: rotate(1turn);\n  }\n}\n\n/*\n * Під reduced-motion обертання зупиняє глобальний вимикач у main.css —\n * так само, як у Progress і LoadingDots. Щоб застигле коло все одно\n * читалося як «вантажиться», а не як іконка, дуга стає довшою: три чверті\n * кола — впізнаваний статичний гліф очікування.\n */\n@media (prefers-reduced-motion: reduce) {\n  .ui-spinner-arc {\n    stroke-dasharray: 75 100;\n  }\n}\n</style>\n"
    },
    {
      "path": "app/composables/useFocusTrap.ts",
      "url": "/registry/source/app/composables/useFocusTrap.ts.txt",
      "sha256": "2f8530f4bca3efd654f871bd7a0c7c6d06ae42e000c16ff016411ce92821ff8c",
      "content": "/**\n * Утримання фокуса всередині відкритого оверлея + повернення фокуса назад.\n *\n * Пишемо руками, а не беремо focus-trap: залежність заради ~150 рядків не\n * варта того, а головне — жодна готова пастка не вміє того, що описано\n * нижче про телепортовані випадайки.\n *\n * Що робить:\n *   - запам'ятовує елемент, з якого відкрили оверлей, і повертає йому фокус;\n *   - зациклює Tab / Shift+Tab у межах панелі (без `cycleTab: false`);\n *   - помічає решту прямих дітей <body> як inert + aria-hidden, щоб фон не\n *     ловив фокус і не читався скрінрідером.\n *\n * Вкладеність працює з лічильником на кожен елемент фону: коли поверх\n * drawer'а відкривається modal, її пастка помічає inert'ом і корінь drawer'а\n * теж, а атрибути повертаються лише тоді, коли елемент відпустила ОСТАННЯ\n * пастка, що його тримала. Раніше кожна пастка відновлювала власний знімок\n * атрибутів, і закриття не в порядку LIFO (обидва оверлеї одним кліком,\n * навігація, drawer із модалкою в слоті) лишало корінь застосунку з\n * inert + aria-hidden назавжди: сторінка переставала реагувати на все.\n *\n * Важливий нюанс — телепортовані випадайки. UiSelect і UiMenu рендерять список\n * прямо в <body>, тобто ФОРМАЛЬНО поза панеллю. Тому «фон» визначається не як\n * «усе поза контейнером», а як «те, що ми позначили inert у момент активації»:\n * елементи, які з'явилися пізніше (та сама випадайка), лишаються клікабельними\n * й фокусованими.\n */\n\nimport { getCurrentScope, onScopeDispose } from 'vue'\n\n/**\n * `import.meta.client` замінено на перевірку document: бібліотеку копіюють\n * і у Vite-проєкти без Nuxt, де цього прапорця не існує.\n */\nconst isClient = typeof document !== 'undefined'\n\ninterface TrapEntry {\n  getContainer: () => HTMLElement | null | undefined;\n  /** Зациклювати Tab у панелі — див. FocusTrapOptions.cycleTab. */\n  cycleTab: boolean;\n  /** Елементи фону, які ця пастка тримає прихованими. */\n  hidden: HTMLElement[];\n  /** Куди повернути фокус після закриття. */\n  restoreFocus: HTMLElement | null;\n}\n\n/** Хто скільки разів приховав елемент фону і що в нього було до того. */\ninterface HiddenState {\n  count: number;\n  inert: string | null;\n  ariaHidden: string | null;\n}\n\nconst FOCUSABLE_SELECTOR = [\n  \"a[href]\",\n  \"area[href]\",\n  \"button:not([disabled])\",\n  'input:not([disabled]):not([type=\"hidden\"])',\n  \"select:not([disabled])\",\n  \"textarea:not([disabled])\",\n  \"iframe\",\n  \"audio[controls]\",\n  \"video[controls]\",\n  '[contenteditable]:not([contenteditable=\"false\"])',\n  '[tabindex]:not([tabindex=\"-1\"])',\n  \"details > summary:first-of-type\",\n].join(\",\");\n\nconst trapStack: TrapEntry[] = [];\nconst hiddenStates = new Map<HTMLElement, HiddenState>();\nlet listenersAttached = false;\n\nconst isVisible = (element: HTMLElement): boolean =>\n  element.getClientRects().length > 0 &&\n  window.getComputedStyle(element).visibility !== \"hidden\";\n\nconst getFocusable = (container: HTMLElement): HTMLElement[] =>\n  Array.from(container.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR)).filter(\n    (element) => !element.hasAttribute(\"inert\") && isVisible(element)\n  );\n\n/** Чи дійде до елемента Tab: не під inert, видимий, без tabindex=\"-1\". */\nconst isTabbable = (element: HTMLElement): boolean =>\n  element.tabIndex >= 0 && !element.closest(\"[inert]\") && isVisible(element);\n\n/** Елементи контейнера в порядку, у якому їх обходить Tab. */\nexport const getTabbable = (container: ParentNode): HTMLElement[] =>\n  Array.from(container.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR)).filter(isTabbable);\n\n/**\n * Фокус на елемент, до якого дійшов би Tab ПІСЛЯ `reference`.\n *\n * Потрібно телепортованим панелям (UiPopover, UiMenu, UiHoverCard): у DOM\n * вони стоять у кінці <body>, і нативний Tab з їхнього останнього пункту\n * виводив би фокус за межі сторінки замість елемента, що йде за тригером.\n * `skip` — піддерева, які не рахуються (сама панель).\n */\nexport function focusNextAfter(\n  reference: Element,\n  skip: Array<Element | null | undefined> = []\n): boolean {\n  if (!isClient) return false;\n  for (const element of Array.from(document.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR))) {\n    if (reference.contains(element)) continue;\n    if (!(reference.compareDocumentPosition(element) & Node.DOCUMENT_POSITION_FOLLOWING)) continue;\n    if (skip.some((node) => node?.contains(element))) continue;\n    if (!isTabbable(element)) continue;\n    element.focus();\n    return true;\n  }\n  return false;\n}\n\nconst topEntry = (): TrapEntry | undefined => trapStack[trapStack.length - 1];\n\n/** Чи належить вузол до фону, який ми самі позначили inert. */\nconst isInHiddenBackground = (entry: TrapEntry, node: Node | null): boolean =>\n  !!node && entry.hidden.some((element) => element.contains(node));\n\nconst onKeyDown = (event: KeyboardEvent): void => {\n  if (event.key !== \"Tab\") return;\n\n  const entry = topEntry();\n  const container = entry?.getContainer();\n  if (!entry || !container || !entry.cycleTab) return;\n\n  const active = document.activeElement;\n  // Фокус у телепортованій випадайці — не заважаємо їй обробляти Tab самій.\n  if (active && !container.contains(active) && !isInHiddenBackground(entry, active)) {\n    return;\n  }\n\n  const focusable = getFocusable(container);\n  if (focusable.length === 0) {\n    event.preventDefault();\n    container.focus({ preventScroll: true });\n    return;\n  }\n\n  const first = focusable[0]!;\n  const last = focusable[focusable.length - 1]!;\n  const isInside = active ? container.contains(active) : false;\n\n  if (event.shiftKey) {\n    if (!isInside || active === first || active === container) {\n      event.preventDefault();\n      last.focus({ preventScroll: true });\n    }\n    return;\n  }\n\n  if (!isInside || active === last) {\n    event.preventDefault();\n    first.focus({ preventScroll: true });\n  }\n};\n\nconst onFocusIn = (event: FocusEvent): void => {\n  const entry = topEntry();\n  const container = entry?.getContainer();\n  if (!entry || !container) return;\n\n  const target = event.target as Node | null;\n  if (!target || container.contains(target)) return;\n  // Витягуємо фокус назад лише з того, що ми самі сховали як фон.\n  if (!isInHiddenBackground(entry, target)) return;\n\n  const focusable = getFocusable(container);\n  (focusable[0] ?? container).focus({ preventScroll: true });\n};\n\nconst attachListeners = (): void => {\n  if (listenersAttached) return;\n  document.addEventListener(\"keydown\", onKeyDown, true);\n  document.addEventListener(\"focusin\", onFocusIn, true);\n  listenersAttached = true;\n};\n\nconst detachListeners = (): void => {\n  if (!listenersAttached) return;\n  document.removeEventListener(\"keydown\", onKeyDown, true);\n  document.removeEventListener(\"focusin\", onFocusIn, true);\n  listenersAttached = false;\n};\n\n/** Прямий нащадок <body>, усередині якого лежить панель оверлея. */\nconst overlayRootOf = (container: HTMLElement): HTMLElement => {\n  let node: HTMLElement = container;\n  while (node.parentElement && node.parentElement !== document.body) {\n    node = node.parentElement;\n  }\n  return node;\n};\n\nconst hideBackground = (entry: TrapEntry, container: HTMLElement): void => {\n  const ownRoot = overlayRootOf(container);\n\n  for (const child of Array.from(document.body.children)) {\n    if (!(child instanceof HTMLElement)) continue;\n    if (child === ownRoot) continue;\n    if (child.hasAttribute(\"data-overlay-ignore\")) continue;\n    if (child.tagName === \"SCRIPT\" || child.tagName === \"STYLE\") continue;\n\n    const state = hiddenStates.get(child);\n    if (state) {\n      // Уже прихований іншою пасткою: запам'ятовуємо лише, що тримаємо його\n      // теж. Знімок атрибутів у ТОЇ пастки — це і є справжні вихідні значення.\n      state.count += 1;\n    } else {\n      hiddenStates.set(child, {\n        count: 1,\n        inert: child.getAttribute(\"inert\"),\n        ariaHidden: child.getAttribute(\"aria-hidden\"),\n      });\n      child.setAttribute(\"inert\", \"\");\n      child.setAttribute(\"aria-hidden\", \"true\");\n    }\n    entry.hidden.push(child);\n  }\n};\n\nconst restoreBackground = (entry: TrapEntry): void => {\n  for (const element of entry.hidden) {\n    const state = hiddenStates.get(element);\n    if (!state) continue;\n    state.count -= 1;\n    if (state.count > 0) continue;\n\n    hiddenStates.delete(element);\n    if (state.inert === null) element.removeAttribute(\"inert\");\n    else element.setAttribute(\"inert\", state.inert);\n\n    if (state.ariaHidden === null) element.removeAttribute(\"aria-hidden\");\n    else element.setAttribute(\"aria-hidden\", state.ariaHidden);\n  }\n  entry.hidden.length = 0;\n};\n\nexport interface FocusTrapOptions {\n  /**\n   * Зациклювати Tab у межах панелі (типово так). `false` — Tab обходить\n   * сторінку сам: фон однаково inert, тож браузер проходить лише панель,\n   * шари над нею й тости (через рядок адреси, як нативний `<dialog>`).\n   * Для шару з віджетом, що сам забирає клавіатуру (віддалене керування,\n   * термінал): пастка слухає Tab у фазі захоплення, раніше за віджет, і на\n   * першому чи останньому елементі панелі забрала б клавішу собі.\n   */\n  cycleTab?: boolean;\n}\n\nexport interface FocusTrapActivateOptions {\n  /** CSS-селектор усередині панелі або готовий елемент. */\n  initialFocus?: string | HTMLElement | null;\n}\n\nexport const useFocusTrap = (\n  getContainer: () => HTMLElement | null | undefined,\n  trapOptions: FocusTrapOptions = {}\n) => {\n  let entry: TrapEntry | null = null;\n\n  const activate = (options: FocusTrapActivateOptions = {}): void => {\n    if (!isClient || entry) return;\n    const container = getContainer();\n    if (!container) return;\n\n    entry = {\n      getContainer,\n      cycleTab: trapOptions.cycleTab ?? true,\n      hidden: [],\n      restoreFocus:\n        document.activeElement instanceof HTMLElement ? document.activeElement : null,\n    };\n    trapStack.push(entry);\n    attachListeners();\n\n    // Спочатку фокус, потім inert: інакше inert на предку активного елемента\n    // збив би фокус у <body> ще до того, як ми його перенесли.\n    let target: HTMLElement | null = null;\n    if (typeof options.initialFocus === \"string\") {\n      target = container.querySelector<HTMLElement>(options.initialFocus);\n    } else if (options.initialFocus instanceof HTMLElement) {\n      target = options.initialFocus;\n    }\n    // Дефолт — сама панель, а не перший інпут: на мобільних автофокус в\n    // інпуті одразу піднімає клавіатуру і з'їдає пів екрана.\n    (target ?? container).focus({ preventScroll: true });\n\n    hideBackground(entry, container);\n  };\n\n  const deactivate = (): void => {\n    if (!isClient || !entry) return;\n    const current = entry;\n    entry = null;\n\n    restoreBackground(current);\n\n    const index = trapStack.indexOf(current);\n    const wasTop = index === trapStack.length - 1;\n    if (index > -1) trapStack.splice(index, 1);\n    if (trapStack.length === 0) detachListeners();\n\n    if (index > -1 && !wasTop) {\n      // Поверх ще відкрита інша пастка — повертати фокус зарано, він украв\n      // би його з видимого діалогу. Якщо її власна ціль повернення лежить у\n      // нашій панелі (яка зараз зникне), вона успадковує нашу: фокус має\n      // повернутися на кнопку, з якої відкрили весь ланцюжок, а не в <body>.\n      const above = trapStack[index];\n      const container = current.getContainer();\n      const orphaned =\n        !above?.restoreFocus ||\n        !above.restoreFocus.isConnected ||\n        !!container?.contains(above.restoreFocus);\n      if (above && orphaned) above.restoreFocus = current.restoreFocus;\n      return;\n    }\n\n    const target = current.restoreFocus;\n    if (target && document.contains(target)) {\n      target.focus({ preventScroll: true });\n    }\n  };\n\n  if (getCurrentScope()) onScopeDispose(deactivate);\n\n  return { activate, deactivate };\n};\n"
    },
    {
      "path": "app/composables/useFullscreen.ts",
      "url": "/registry/source/app/composables/useFullscreen.ts.txt",
      "sha256": "ebf8d12f282748921522bc041859d76c8dccb6400f895ecb061c745f3c3feeb6",
      "content": "import { getCurrentInstance, getCurrentScope, onMounted, onScopeDispose, shallowRef } from 'vue'\n\n/**\n * Повноекранний режим через Fullscreen API.\n *\n * Навіщо обгортка, а не прямий `requestFullscreen()`:\n *\n * 1. Safari на iPad до 16.4 знає лише префіксовані `webkit*`-методи, а на\n *    iPhone елементи, крім `<video>`, на весь екран не розгортаються взагалі.\n *    Тому `supported` — чесна перевірка, і кнопку, яка нічого не зробить,\n *    компонент просто не показує.\n *\n * 2. Режим можна покинути повз нас: Escape, жест, системна кнопка. Стан\n *    синхронізується з подією `fullscreenchange`, а не з тим, що ми\n *    востаннє викликали, — інакше кнопка показувала б «Вийти», коли виходити\n *    вже нема звідки.\n *\n * 3. `exitIfEntered()` виходить лише з режиму, який увімкнули саме ми:\n *    закриття галереї не має викидати з повного екрана відео, яке людина\n *    розгорнула сама.\n *\n * `supported` виставляється в onMounted, а не при створенні: на сервері й\n * у першому клієнтському рендері значення мусить бути однаковим, інакше\n * гідрація розійдеться на кнопці в панелі інструментів.\n */\n\ninterface WebkitDocument {\n  webkitFullscreenEnabled?: boolean\n  webkitFullscreenElement?: Element | null\n  webkitExitFullscreen?: () => Promise<void> | void\n}\n\ninterface WebkitElement {\n  webkitRequestFullscreen?: () => Promise<void> | void\n}\n\nconst isClient = typeof document !== 'undefined'\n\nfunction fullscreenElement(): Element | null {\n  if (!isClient) return null\n  return document.fullscreenElement ?? (document as Document & WebkitDocument).webkitFullscreenElement ?? null\n}\n\nfunction fullscreenEnabled(): boolean {\n  if (!isClient) return false\n  const legacy = document as Document & WebkitDocument\n  return !!(document.fullscreenEnabled || legacy.webkitFullscreenEnabled)\n}\n\nexport function useFullscreen() {\n  const supported = shallowRef(false)\n  const active = shallowRef(false)\n  let entered = false\n\n  function sync() {\n    const now = !!fullscreenElement()\n    // Скидаємо «увімкнули ми» лише на справжньому виході. Префіксований\n    // webkitRequestFullscreen нічого не повертає, і одразу після виклику\n    // режим ще не ввімкнувся — перевірка «зараз не на весь екран» тут\n    // забула б, що вмикали саме ми.\n    if (active.value && !now) entered = false\n    active.value = now\n  }\n\n  async function enter(target: Element = document.documentElement): Promise<void> {\n    if (!isClient || !supported.value || fullscreenElement()) return\n    const legacy = target as Element & WebkitElement\n    entered = true\n    try {\n      if (target.requestFullscreen) await target.requestFullscreen()\n      else await legacy.webkitRequestFullscreen?.()\n    } catch {\n      entered = false\n      // Браузер відмовив (немає жесту користувача, політика iframe) —\n      // лишаємось у звичайному режимі, стан підтягне fullscreenchange.\n    }\n    sync()\n  }\n\n  async function exit(): Promise<void> {\n    if (!isClient || !fullscreenElement()) return\n    const legacy = document as Document & WebkitDocument\n    try {\n      if (document.exitFullscreen) await document.exitFullscreen()\n      else await legacy.webkitExitFullscreen?.()\n    } catch {\n      // Режим уже покинули іншим шляхом — нічого робити.\n    }\n    entered = false\n    sync()\n  }\n\n  function toggle(target?: Element): Promise<void> {\n    return fullscreenElement() ? exit() : enter(target)\n  }\n\n  /** Вийти, лише якщо повний екран увімкнули через цей екземпляр. */\n  function exitIfEntered(): Promise<void> {\n    return entered ? exit() : Promise.resolve()\n  }\n\n  function listen() {\n    supported.value = fullscreenEnabled()\n    sync()\n    document.addEventListener('fullscreenchange', sync)\n    document.addEventListener('webkitfullscreenchange', sync)\n  }\n\n  // У компоненті — після монтування (див. про гідрацію вище); поза ним\n  // (тест, окремий effectScope) — одразу.\n  if (getCurrentInstance()) onMounted(listen)\n  else if (isClient) listen()\n\n  if (getCurrentScope()) {\n    onScopeDispose(() => {\n      if (!isClient) return\n      document.removeEventListener('fullscreenchange', sync)\n      document.removeEventListener('webkitfullscreenchange', sync)\n    })\n  }\n\n  return { supported, active, enter, exit, toggle, exitIfEntered }\n}\n"
    },
    {
      "path": "app/composables/useOverlayStack.ts",
      "url": "/registry/source/app/composables/useOverlayStack.ts.txt",
      "sha256": "139a7767c245421f238e36641aec08a554fe9c115cf97892ad165eb5225cf52d",
      "content": "import { computed, getCurrentScope, onScopeDispose, readonly, ref } from 'vue'\nimport type { ComputedRef } from 'vue'\n\n/**\n * Єдиний стек шарів для всіх оверлеїв: UiModal, UiDrawer, UiConfirmDialog —\n * і плаваючих панелей: UiPopover, UiMenu, UiContextMenu, UiTooltip, UiHoverCard.\n *\n * Навіщо один стек на всіх. У вихідних проєктах кожен оверлей\n * рахував z-index сам: Modal мав власний стек із 1001+, Drawer —\n * захардкоджений z-[1000], ConfirmDialog — z-index: 99999. Через це drawer,\n * відкритий із модалки, опинявся ПІД нею, а два drawer'и один над одним\n * розрулювалися лише порядком у DOM. Спільний стек прибирає весь цей клас\n * багів і додає `isTopmost` — щоб Escape закривав тільки верхній оверлей,\n * а не всі відкриті одразу.\n *\n * Плаваючі панелі теж у стеку, бо інакше кожна вирішувала Escape і клік\n * «повз» сама: поповер перехоплював Escape у випадайки UiSelect усередині\n * себе, меню під діалогом закривалося замість діалогу, а Escape для\n * підказки в модалці закривав і модалку.\n *\n * Чому база 1000 і крок 10:\n *   - 1000 збігається з тим, що вже було в Drawer/Modal, тож нічого не\n *     «пірнає» під елементи сторінки;\n *   - крок 10 лишає місце для внутрішніх шарів панелі (sticky-хедер, футер);\n *   - UiSelect телепортує випадайку з z-[1100], тож перші ~10 шарів\n *     гарантовано лишаються нижче за неї — селект усередині оверлея видно.\n *\n * Стан модульний, а не через useState: він суто клієнтський, у payload SSR\n * йому робити нічого.\n */\n\n/**\n * `import.meta.client` тут не використовується навмисно — це специфіка\n * Nuxt, а бібліотеку копіюють і у Vite-проєкти без нього. Перевірка на\n * document працює скрізь.\n */\nconst isClient = typeof document !== 'undefined'\n\nexport const OVERLAY_BASE_Z_INDEX = 1000\nexport const OVERLAY_Z_STEP = 10\n\nconst overlayStack = ref<string[]>([])\nlet overlayIdCounter = 0\n\n/**\n * Поведінка шару понад саме місце в стеку. Модальні шари реєструють тут\n * лише onEscape; плаваючі — ще й межі для кліку «повз».\n */\ninterface LayerEntry {\n  floating: boolean\n  /**\n   * Пасивний шар (підказка, hover-картка) отримує Escape, але не забирає\n   * `isTopmost` у шару під собою: стрілки в галереї мають гортати, навіть\n   * поки над кнопкою висить підказка.\n   */\n  passive: boolean\n  onEscape?: (event: KeyboardEvent) => void\n  /** Системне «назад», коли шар верхній; без нього «назад» іде як Escape. */\n  onBack?: () => void\n  elements?: () => Array<Element | null | undefined>\n  onPointerDownOutside?: (event: PointerEvent) => void\n  /** Прямі діти <body> на момент відкриття — усе пізніше є шаром над нами. */\n  bodyChildren?: Set<Element>\n}\n\nconst layerEntries = new Map<string, LayerEntry>()\n\n/*\n * Скільки відкрито шарів, які людина закриває сама: модальні й плаваючі\n * панелі, без пасивних (підказка, hover-картка). Записи шару стають у\n * layerEntries до push у стек, тож пасивність відома з першого перерахунку.\n * Потрібно, наприклад, щоб системне «назад» на телефоні закривало верхній\n * шар, а не йшло з екрана під ним.\n */\nconst blockingLayerCount = computed(\n  () => overlayStack.value.filter((id) => !layerEntries.get(id)?.passive).length,\n)\n\nexport function useOverlayStack() {\n  const push = (id: string): void => {\n    if (!isClient || overlayStack.value.includes(id)) return\n    overlayStack.value.push(id)\n  }\n\n  const remove = (id: string): void => {\n    if (!isClient) return\n    const index = overlayStack.value.indexOf(id)\n    if (index > -1) overlayStack.value.splice(index, 1)\n  }\n\n  const indexOf = (id: string): number => overlayStack.value.indexOf(id)\n\n  /** Пасивні шари над `id` не рахуються — див. LayerEntry.passive. */\n  const isTopmost = (id: string): boolean => {\n    for (let index = overlayStack.value.length - 1; index >= 0; index -= 1) {\n      const current = overlayStack.value[index]!\n      if (current === id) return true\n      if (!layerEntries.get(current)?.passive) return false\n    }\n    return false\n  }\n\n  const zIndexFor = (id: string): number => {\n    const index = overlayStack.value.indexOf(id)\n    if (index === -1) return OVERLAY_BASE_Z_INDEX\n    // Плаваючі панелі мають власну шкалу від 1100 (getOverlayChildZIndex) і\n    // в крок модальних не входять: інакше відкрита підказка зсувала б\n    // z-index модалки, що відкривається після неї.\n    let modalIndex = 0\n    for (let position = 0; position < index; position += 1) {\n      if (!layerEntries.get(overlayStack.value[position]!)?.floating) modalIndex += 1\n    }\n    return OVERLAY_BASE_Z_INDEX + modalIndex * OVERLAY_Z_STEP\n  }\n\n  /**\n   * Чим верхній шар (пасивні не рахуються) відповідає на системне «назад»,\n   * якщо передав власне — див. OverlayLayerOptions.onBack. `undefined` —\n   * «назад» іде звичайним шляхом Escape.\n   */\n  const topmostBack = (): (() => void) | undefined => {\n    for (let index = overlayStack.value.length - 1; index >= 0; index -= 1) {\n      const entry = layerEntries.get(overlayStack.value[index]!)\n      if (!entry?.passive) return entry?.onBack\n    }\n    return undefined\n  }\n\n  return { stack: readonly(overlayStack), blockingCount: blockingLayerCount, push, remove, indexOf, isTopmost, zIndexFor, topmostBack }\n}\n\n/* ------------------------------------------------------------------ */\n/*  Спільні слухачі: Escape і клік «повз»                             */\n/* ------------------------------------------------------------------ */\n\n/**\n * Escape дістається рівно ОДНОМУ шару — останньому в стеку.\n *\n * Фаза спливання, а не захоплення: UiSelect, UiCombobox і решта обробляють\n * Escape на своєму елементі й зупиняють його там. Слухач у фазі захоплення\n * випереджав їх — так поповер закривався цілком, коли людина лише хотіла\n * згорнути список селекта всередині нього.\n *\n * Якщо останній шар не передав onEscape (UiSidebar, UiLightbox мають власні\n * слухачі), нічого не робимо: вони розберуться самі через isTopmost.\n */\nfunction onDocumentKeydown(event: KeyboardEvent): void {\n  if (event.key !== 'Escape' || event.defaultPrevented || event.isComposing) return\n  const topId = overlayStack.value[overlayStack.value.length - 1]\n  const entry = topId ? layerEntries.get(topId) : undefined\n  if (!entry?.onEscape) return\n  // stopImmediatePropagation: інші оверлеї слухають той самий document, і\n  // шар під нами, побачивши себе верхнім після нашого закриття, закрився б\n  // тим самим натиском.\n  event.preventDefault()\n  event.stopImmediatePropagation()\n  entry.onEscape(event)\n}\n\n/** Прямий нащадок <body>, у якому лежить вузол. */\nfunction bodyChildOf(node: Node): Element | null {\n  let current: Node | null = node\n  while (current && current.parentNode !== document.body) current = current.parentNode\n  return current instanceof Element ? current : null\n}\n\n/**\n * Клік «усередині» шару — це його власні елементи АБО будь-що, що з'явилося\n * в <body> після його відкриття: випадайка UiSelect, відкрита з поповера,\n * вкладене меню, діалог поверх. Список ролей-винятків ([role=\"dialog\"])\n * тут не працює: меню в модалці переставало закриватися від кліку деінде в\n * тій самій модалці, бо вона теж dialog.\n */\nfunction isInsideLayer(entry: LayerEntry, target: Node): boolean {\n  if (entry.elements?.().some((element) => element?.contains(target))) return true\n  const root = bodyChildOf(target)\n  return !!root && !!entry.bodyChildren && !entry.bodyChildren.has(root)\n}\n\nfunction onDocumentPointerDown(event: PointerEvent): void {\n  const target = event.target\n  if (!(target instanceof Node)) return\n  // Копія і від верхнього до нижнього: обробники закривають шари прямо тут.\n  const ids = [...overlayStack.value].reverse()\n  for (const id of ids) {\n    const entry = layerEntries.get(id)\n    if (!entry?.onPointerDownOutside || isInsideLayer(entry, target)) continue\n    entry.onPointerDownOutside(event)\n  }\n}\n\n/*\n * Слухачі ставляться ОДИН раз, під час завантаження модуля — тобто раніше\n * за будь-який слухач компонента на тому ж document. Порядок тут і є\n * гарантія: Escape для підказки в UiLightbox встигає зупинитися до того, як\n * його побачить власний обробник галереї.\n *\n * Прапорець на window прибирає слухачі попередньої копії модуля після\n * гарячого перезавантаження, інакше в dev їх ставало б два.\n */\nif (isClient) {\n  const registry = window as Window & {\n    __uiOverlayListeners?: { keydown: typeof onDocumentKeydown; pointerdown: typeof onDocumentPointerDown }\n  }\n  const previous = registry.__uiOverlayListeners\n  if (previous) {\n    document.removeEventListener('keydown', previous.keydown)\n    document.removeEventListener('pointerdown', previous.pointerdown, true)\n  }\n  document.addEventListener('keydown', onDocumentKeydown)\n  document.addEventListener('pointerdown', onDocumentPointerDown, true)\n  registry.__uiOverlayListeners = { keydown: onDocumentKeydown, pointerdown: onDocumentPointerDown }\n}\n\n/* ------------------------------------------------------------------ */\n/*  Модальний шар                                                      */\n/* ------------------------------------------------------------------ */\n\nexport interface OverlayLayerOptions {\n  /**\n   * Escape, коли цей шар верхній. Спільний слухач гарантує, що спрацює\n   * рівно один шар — і що підказка чи меню над ним отримають Escape першими.\n   */\n  onEscape?: (event: KeyboardEvent) => void\n  /**\n   * Системне «назад» (`useSystemBack`), коли цей шар верхній. Без нього\n   * «назад» закриває шар тим самим шляхом, що й Escape. Потрібне шару, який\n   * на Escape не реагує, а на «назад» має: дзвінок на весь екран\n   * згортається у вікно, хоча клавіша Escape його не чіпає.\n   */\n  onBack?: () => void\n}\n\nexport interface OverlayLayer {\n  id: string\n  zIndex: ComputedRef<number>\n  isTopmost: ComputedRef<boolean>\n  activate: () => void\n  /** Прибрати шар зі стеку, лишивши z-index на час анімації виходу. */\n  deactivate: () => void\n  /** Відпустити заморожений z-index. Викликати з `@after-leave`. */\n  settle: () => void\n}\n\n/**\n * Обгортка «один компонент — один шар». Компонент лише кличе\n * activate()/deactivate() і читає zIndex/isTopmost.\n *\n * Шар виходить зі стеку ОДРАЗУ на закритті, а не по завершенні анімації.\n * Інакше будь-який незавершений leave (перервана анімація, фонова вкладка,\n * де не тікає requestAnimationFrame) лишав би мертвий запис у стеку — і\n * тоді isTopmost брехав би, а Escape перестав би закривати видимий оверлей.\n * Щоб панель, яка закривається, не пірнула під сусідній оверлей, її z-index\n * на цей час фіксується і відпускається у settle().\n */\nexport function useOverlayLayer(id?: string, options: OverlayLayerOptions = {}): OverlayLayer {\n  const stack = useOverlayStack()\n  const layerId = id ?? `overlay-${++overlayIdCounter}`\n  const frozenZIndex = ref<number | null>(null)\n\n  const activate = () => {\n    frozenZIndex.value = null\n    if (isClient && (options.onEscape || options.onBack)) {\n      layerEntries.set(layerId, { floating: false, passive: false, onEscape: options.onEscape, onBack: options.onBack })\n    }\n    stack.push(layerId)\n  }\n\n  const deactivate = () => {\n    if (stack.indexOf(layerId) > -1) frozenZIndex.value = stack.zIndexFor(layerId)\n    stack.remove(layerId)\n    layerEntries.delete(layerId)\n  }\n\n  const settle = () => {\n    frozenZIndex.value = null\n  }\n\n  // Компонент може бути знищений у відкритому стані (навігація під час\n  // відкритого drawer'а) — шар не має лишатися у стеку назавжди.\n  if (getCurrentScope()) onScopeDispose(deactivate)\n\n  return {\n    id: layerId,\n    zIndex: computed(() => frozenZIndex.value ?? stack.zIndexFor(layerId)),\n    isTopmost: computed(() => stack.isTopmost(layerId)),\n    activate,\n    deactivate,\n    settle,\n  }\n}\n\n/* ------------------------------------------------------------------ */\n/*  Плаваючий шар                                                      */\n/* ------------------------------------------------------------------ */\n\nexport interface FloatingLayerOptions {\n  /** Панель і її власник (тригер, корінь): натискання в них — не «повз». */\n  elements: () => Array<Element | null | undefined>\n  /** Escape, коли цей шар останній у стеку. */\n  onEscape?: (event: KeyboardEvent) => void\n  /** Натискання поза шаром і поза всім, що відкрилося пізніше за нього. */\n  onPointerDownOutside?: (event: PointerEvent) => void\n  /**\n   * Підказка чи hover-картка: отримує Escape, але не забирає `isTopmost` у\n   * шару під собою — див. LayerEntry.passive.\n   */\n  passive?: boolean\n}\n\nexport interface FloatingLayer {\n  id: string\n  /** Чи цей шар зараз верхній (пасивні шари над ним не рахуються). */\n  isTopmost: ComputedRef<boolean>\n  /** Зареєструвати панель, що відкрилася. Повторний виклик нічого не робить. */\n  activate: () => void\n  /** Зняти панель зі стеку. Повторний виклик нічого не робить. */\n  deactivate: () => void\n}\n\n/**\n * Шар для немодальних панелей: UiPopover, UiMenu, UiContextMenu, UiTooltip,\n * UiHoverCard. Компонент кличе activate() на відкритті й deactivate() на\n * закритті, а Escape і клік «повз» приходять у передані обробники.\n */\nexport function useFloatingLayer(options: FloatingLayerOptions): FloatingLayer {\n  const stack = useOverlayStack()\n  const layerId = `floating-${++overlayIdCounter}`\n\n  const activate = () => {\n    if (!isClient || layerEntries.has(layerId)) return\n    layerEntries.set(layerId, {\n      floating: true,\n      passive: !!options.passive,\n      onEscape: options.onEscape,\n      elements: options.elements,\n      onPointerDownOutside: options.onPointerDownOutside,\n      bodyChildren: new Set(Array.from(document.body.children)),\n    })\n    stack.push(layerId)\n  }\n\n  const deactivate = () => {\n    if (!layerEntries.has(layerId)) return\n    stack.remove(layerId)\n    layerEntries.delete(layerId)\n  }\n\n  if (getCurrentScope()) onScopeDispose(deactivate)\n\n  return {\n    id: layerId,\n    isTopmost: computed(() => stack.isTopmost(layerId)),\n    activate,\n    deactivate,\n  }\n}\n"
    },
    {
      "path": "app/composables/useReducedMotion.ts",
      "url": "/registry/source/app/composables/useReducedMotion.ts.txt",
      "sha256": "5de4fa3e2ef180997e2a0dff9156091436369e5f3dfb67c3f746496da84269bf",
      "content": "import { getCurrentScope, onScopeDispose, ref } from 'vue'\n\n/**\n * Чи просив користувач прибрати анімації (prefers-reduced-motion: reduce).\n *\n * Потрібно не лише для CSS: у <Transition> тривалість задана явно через\n * :duration, тож без цієї перевірки елемент чекав би повні 300 мс у DOM\n * навіть із вимкненою анімацією — оверлей візуально зник, а клікам ще\n * третину секунди заважає невидима панель.\n */\nexport function useReducedMotion() {\n  const prefersReducedMotion = ref(false)\n\n  if (typeof window !== 'undefined' && typeof window.matchMedia === 'function') {\n    const query = window.matchMedia('(prefers-reduced-motion: reduce)')\n    prefersReducedMotion.value = query.matches\n\n    const onChange = (event: MediaQueryListEvent) => {\n      prefersReducedMotion.value = event.matches\n    }\n\n    query.addEventListener('change', onChange)\n    if (getCurrentScope()) {\n      onScopeDispose(() => query.removeEventListener('change', onChange))\n    }\n  }\n\n  return prefersReducedMotion\n}\n\n/**\n * Тривалість токена руху (`--duration-slow`, …) у мілісекундах.\n *\n * `<Transition :duration>` потребує ЧИСЛА, а CSS анімує за токеном. Поки\n * число стояло літералом (260, 350…), проєкт, що перевизначив\n * `--duration-slow`, отримував обрізану анімацію: Vue прибирав вузол\n * раніше, ніж CSS її докручував. `fallback` — значення з tokens.css, для\n * SSR і середовищ без стилів.\n */\nexport function readDurationToken(name: `--${string}`, fallback: number): number {\n  if (typeof window === 'undefined' || typeof document === 'undefined') return fallback\n  const raw = window.getComputedStyle(document.documentElement).getPropertyValue(name).trim()\n  const value = Number.parseFloat(raw)\n  if (!Number.isFinite(value)) return fallback\n  return raw.endsWith('ms') ? value : raw.endsWith('s') ? value * 1000 : value\n}\n"
    },
    {
      "path": "app/composables/useScrollLock.ts",
      "url": "/registry/source/app/composables/useScrollLock.ts.txt",
      "sha256": "c7f80be62ce5fafdaba72ceb029090bcc7a359283130dad9139d5c8e4ea7b9c4",
      "content": "import { getCurrentScope, onScopeDispose } from 'vue'\n\n/**\n * Блокування прокрутки сторінки під оверлеєм — зі счітчиком і робоче на iOS.\n *\n * Дві проблеми, які це лікує:\n *\n * 1. Вкладеність. У вихідних проєктах кожен оверлей безумовно писав і\n *    скидав `document.body.style.overflow`. У типовому потоці (confirm\n *    поверх drawer'а, modal усередині drawer'а) закриття внутрішнього\n *    оверлея розблоковувало скрол, поки зовнішній ще відкритий. Тут лок\n *    рахується: фон розблоковується лише коли закрився ОСТАННІЙ оверлей.\n *\n * 2. iOS Safari. `overflow: hidden` на body там не зупиняє прокрутку — фон\n *    продовжує «гумитися» під drawer'ом. Робочий спосіб — `position: fixed`\n *    зі збереженням і подальшим відновленням scrollY.\n *\n * Плюс компенсація ширини скролбара, щоб контент не стрибав на десктопі,\n * і `data-overlay-scroll-locked` на body як хук для CSS.\n */\n\nconst isClient = typeof document !== 'undefined'\n\nlet lockCount = 0\nlet releaseDom: (() => void) | null = null\n\nfunction applyDomLock(): void {\n  const body = document.body\n  const html = document.documentElement\n\n  const scrollY = window.scrollY\n  // innerWidth - clientWidth = ширина класичного скролбара (на мобільних 0).\n  const scrollbarWidth = window.innerWidth - html.clientWidth\n\n  const previous = {\n    position: body.style.position,\n    top: body.style.top,\n    left: body.style.left,\n    right: body.style.right,\n    width: body.style.width,\n    overflow: body.style.overflow,\n    paddingRight: body.style.paddingRight,\n    scrollBehavior: html.style.scrollBehavior,\n  }\n\n  // scroll-behavior: smooth анімував би повернення на місце після закриття.\n  html.style.scrollBehavior = 'auto'\n  body.style.position = 'fixed'\n  body.style.top = `-${scrollY}px`\n  body.style.left = '0'\n  body.style.right = '0'\n  body.style.width = '100%'\n  body.style.overflow = 'hidden'\n  if (scrollbarWidth > 0) {\n    const currentPadding = Number.parseFloat(window.getComputedStyle(body).paddingRight) || 0\n    body.style.paddingRight = `${currentPadding + scrollbarWidth}px`\n  }\n  body.dataset.overlayScrollLocked = 'true'\n\n  releaseDom = () => {\n    body.style.position = previous.position\n    body.style.top = previous.top\n    body.style.left = previous.left\n    body.style.right = previous.right\n    body.style.width = previous.width\n    body.style.overflow = previous.overflow\n    body.style.paddingRight = previous.paddingRight\n    delete body.dataset.overlayScrollLocked\n    window.scrollTo(0, scrollY)\n    html.style.scrollBehavior = previous.scrollBehavior\n  }\n}\n\nfunction acquire(): void {\n  if (!isClient) return\n  lockCount += 1\n  if (lockCount === 1) applyDomLock()\n}\n\nfunction release(): void {\n  if (!isClient || lockCount === 0) return\n  lockCount -= 1\n  if (lockCount === 0 && releaseDom) {\n    releaseDom()\n    releaseDom = null\n  }\n}\n\n/**\n * Один виклик = один потенційний тримач лока. lock()/unlock() ідемпотентні\n * для конкретного споживача, тож подвійний lock() не «залипає» лічильником.\n */\nexport function useScrollLock() {\n  let holding = false\n\n  const lock = (): void => {\n    if (holding) return\n    holding = true\n    acquire()\n  }\n\n  const unlock = (): void => {\n    if (!holding) return\n    holding = false\n    release()\n  }\n\n  if (getCurrentScope()) onScopeDispose(unlock)\n\n  return { lock, unlock }\n}\n"
    },
    {
      "path": "app/composables/useUiText.ts",
      "url": "/registry/source/app/composables/useUiText.ts.txt",
      "sha256": "0fcdb6b52d4ea5ea67ca9c5b83a153bbeb76fa66ba04d8e32759418bd67c3a1b",
      "content": "/** Plain-text translation callback. A reactive locale inside it updates rendered labels. */\nexport type UiTextTranslator = (message: string, values?: Record<string, unknown>) => string\n\nlet translate: UiTextTranslator | undefined\n\n/** Configure once before mounting. Omit the callback to restore Ukrainian defaults. */\nexport function setUiTextTranslator(translator?: UiTextTranslator): void {\n  translate = translator\n}\n\n/** Built-in UI labels; arbitrary values remain text and are never interpreted as HTML. */\nexport function uiText(message: string, values: Record<string, unknown> = {}): string {\n  if (translate) return translate(message, values)\n  return message.replace(/\\{(\\w+)\\}/g, (placeholder, name: string) =>\n    Object.prototype.hasOwnProperty.call(values, name) ? String(values[name] ?? '') : placeholder)\n}\n"
    },
    {
      "path": "app/utils/carousel.ts",
      "url": "/registry/source/app/utils/carousel.ts.txt",
      "sha256": "679c05ca57ec6022531296e441829b7954ceacf6a43cbced6a54a67ac951d13b",
      "content": "/**\n * Чиста логіка перетягування слайдів UiCarousel — поза компонентом, щоб\n * покривати тестами без рендеру (правило дому: поведінка → utils → тести).\n *\n * Два уроки з реальних мобільних пристроїв, які цей модуль кодифікує:\n *\n * 1. Поріг перетягування не може бути фіксованим у пікселях: 40px — це\n *    11% ширини екрана 360px, і «недотягнуті» змахи виглядають як поломка.\n *    Тому поріг масштабується від ширини треку, а швидкий змах (flick)\n *    листає слайд навіть коротшим рухом.\n *\n * 2. Жест треба класифікувати за домінантною віссю ДО того, як щось рухати:\n *    палець майже ніколи не рухається строго горизонтально, і без осьового\n *    блокування діагональний змах одночасно гортав би слайд і сторінку.\n */\n\n/** Наскільки далеко має пройти жест, щоб фіксувати вісь (пікселі). */\nexport const DRAG_AXIS_SLOP_PX = 8\n\n/** Мінімальна дистанція швидкого змаху (пікселі). */\nexport const FLICK_MIN_DISTANCE_PX = 24\n\n/** Максимальна тривалість швидкого змаху (мілісекунди). */\nexport const FLICK_MAX_DURATION_MS = 200\n\n/** Мінімальний поріг у пікселях — нижче нього жести виглядають випадковими. */\nexport const DRAG_MIN_THRESHOLD_PX = 40\n\n/** Частка ширини треку, яку має пройти повільний жест для перемикання. */\nexport const DRAG_VIEWPORT_RATIO = 0.15\n\n/**\n * Поріг перемикання слайда: максимум із фіксованого мінімуму і частки\n * ширини. На телефоні 360px це 54px, на планшеті 800px — 120px, тобто\n * відчуття «дотягнути слайд» однакове на будь-якому екрані.\n */\nexport function dragThreshold(width: number): number {\n  if (!Number.isFinite(width) || width <= 0) return DRAG_MIN_THRESHOLD_PX\n  return Math.max(DRAG_MIN_THRESHOLD_PX, Math.round(width * DRAG_VIEWPORT_RATIO))\n}\n\n/**\n * Вісь жесту після накопичення переміщення.\n *\n * null — ще рано судити (рух менший за поріг), 'x' — горизонтальний,\n * 'y' — вертикальний. Домінанта з невеликим запасом: рівні рухи по\n * діагоналі (|dx| ≈ |dy|) трактуються як вертикаль, бо горизонтальний\n * слайд-жест природно роблять упевнено, а скрол — навіть трохи по дузі.\n */\nexport function dragAxis(dx: number, dy: number, slop = DRAG_AXIS_SLOP_PX): 'x' | 'y' | null {\n  const adx = Math.abs(dx)\n  const ady = Math.abs(dy)\n  if (Math.max(adx, ady) < slop) return null\n  return adx > ady ? 'x' : 'y'\n}\n\n/**\n * Чи перемкнути слайд після завершення жесту.\n *\n * Або жест пройшов поріг відстані, або це швидкий змах — короткий, але\n * рвучкий. Тривалість бере компонент: performance.now() при pointerdown.\n */\nexport function shouldAdvance(options: { dx: number; elapsedMs: number; width: number }): boolean {\n  const { dx, elapsedMs, width } = options\n  if (Math.abs(dx) >= dragThreshold(width)) return true\n  return Math.abs(dx) >= FLICK_MIN_DISTANCE_PX && elapsedMs <= FLICK_MAX_DURATION_MS\n}\n\n/**\n * Гумові краї: без `loop` жест за межами першого/останнього слайда\n * гаситься до чверті відстані — слайд пружинить, а не тягне порожнину.\n */\nexport function rubberBandDelta(delta: number, edges: { atStart: boolean; atEnd: boolean }): number {\n  if ((edges.atStart && delta > 0) || (edges.atEnd && delta < 0)) return delta * 0.25\n  return delta\n}\n\n/**\n * Напрямок перемикання за знаком зсуву.\n *\n * Палець вправо (позитивний dx) тягне слайди назад — «previous».\n */\nexport function swipeDirection(dx: number): 'previous' | 'next' {\n  return dx > 0 ? 'previous' : 'next'\n}"
    },
    {
      "path": "app/utils/lightbox.ts",
      "url": "/registry/source/app/utils/lightbox.ts.txt",
      "sha256": "b54d7322c2d165d41ebdcdec8db9d3d8f127d1e9cc2bd910387dec8d6e87f57e",
      "content": "import { uiText } from '~/composables/useUiText'\n/**\n * Чиста логіка UiLightbox — поза компонентом, щоб покривати тестами без\n * рендеру (правило дому: поведінка → utils → тести). Жести свайпу беруться\n * з utils/carousel: поріг і флік мають відчуватися однаково в каруселі й у\n * галереї.\n *\n * Уся геометрія збільшення рахується в координатах сцени відносно її\n * центру: зображення стоїть у центрі, а `x`/`y` — зсув його центру. Так\n * формули не залежать від того, де на сторінці сцена і чи є в неї відступи.\n */\n\n/* ------------------------------------------------------------------ */\n/*  Індекс і напрямок                                                  */\n/* ------------------------------------------------------------------ */\n\n/**\n * Індекс у межах галереї.\n *\n * Без `loop` — обрізається до країв; з `loop` — загортається по колу, у\n * тому числі від'ємний (−1 → останній). Дріб і NaN не можуть потрапити в\n * `images[i]`: undefined там — це порожня сцена замість фото.\n */\nexport function lightboxIndex(value: number, count: number, loop = false): number {\n  if (count <= 0) return 0\n  const whole = Number.isFinite(value) ? Math.trunc(value) : 0\n  if (loop) return ((whole % count) + count) % count\n  return Math.min(Math.max(whole, 0), count - 1)\n}\n\n/**\n * У який бік їде трек, коли галерея переходить з `from` на `to`.\n *\n * З `loop` сусід через край — теж сусід: з останнього на перший трек їде\n * вперед на один слайд, а не пролітає назад через усю галерею. Дальній\n * перехід (клік по мініатюрі) — за знаком різниці: трек однаково зсувається\n * лише на один слайд, а ціль підставляється поруч.\n */\nexport function slideStep(from: number, to: number, count: number, loop = false): 1 | -1 {\n  if (loop && count > 2) {\n    if ((from + 1) % count === to) return 1\n    if ((from - 1 + count) % count === to) return -1\n  }\n  return to >= from ? 1 : -1\n}\n\n/**\n * Наступний кадр слайдшоу. `null` — зупинитися: без `loop` слайдшоу\n * закінчується на останньому кадрі, а не перескакує мовчки на перший.\n */\nexport function nextSlideshowIndex(current: number, count: number, loop = false): number | null {\n  if (count < 2) return null\n  if (current < count - 1) return current + 1\n  return loop ? 0 : null\n}\n\n/* ------------------------------------------------------------------ */\n/*  Тип вмісту й вбудовані плеєри                                      */\n/* ------------------------------------------------------------------ */\n\n/** Як рендерити слайд. Відео з YouTube і Vimeo — окремі види: у них свій плеєр. */\nexport type LightboxKind = 'image' | 'video' | 'youtube' | 'vimeo' | 'iframe' | 'custom'\n\nconst VIDEO_FILE = /\\.(mp4|webm|ogv|ogg|mov|m4v)(?:$|[?#])/i\n\nfunction parseUrl(src: string): URL | null {\n  try {\n    // База потрібна для відносних адрес (\"/demo/clip.mp4\"): вони валідні,\n    // просто не можуть бути ні YouTube, ні Vimeo.\n    return new URL(src, 'https://lightbox.invalid')\n  } catch {\n    return null\n  }\n}\n\nfunction hostIs(url: URL, domain: string): boolean {\n  return url.hostname === domain || url.hostname.endsWith(`.${domain}`)\n}\n\n/** «1m30s», «90s», «90» → 90. Формат параметра `t` у посиланнях YouTube. */\nfunction parseStart(value: string | null): number {\n  if (!value) return 0\n  if (/^\\d+$/.test(value)) return Number(value)\n  const match = value.match(/^(?:(\\d+)h)?(?:(\\d+)m)?(?:(\\d+)s)?$/)\n  if (!match || !match[0]) return 0\n  return Number(match[1] ?? 0) * 3600 + Number(match[2] ?? 0) * 60 + Number(match[3] ?? 0)\n}\n\n/** Ідентифікатор і стартова секунда відео YouTube з будь-якої форми посилання. */\nexport function youtubeVideo(src: string): { id: string; start: number } | null {\n  const url = parseUrl(src)\n  if (!url) return null\n  let id: string | undefined\n  if (hostIs(url, 'youtu.be')) {\n    id = url.pathname.split('/')[1]\n  } else if (hostIs(url, 'youtube.com') || hostIs(url, 'youtube-nocookie.com')) {\n    const [, section, value] = url.pathname.split('/')\n    if (section === 'watch') id = url.searchParams.get('v') ?? undefined\n    else if (section === 'embed' || section === 'shorts' || section === 'live' || section === 'v') id = value\n  }\n  if (!id || !/^[\\w-]{11}$/.test(id)) return null\n  return { id, start: parseStart(url.searchParams.get('t') ?? url.searchParams.get('start')) }\n}\n\n/** Ідентифікатор відео Vimeo і хеш приватного посилання, якщо він є. */\nexport function vimeoVideo(src: string): { id: string; hash?: string; time?: string } | null {\n  const url = parseUrl(src)\n  if (!url || !hostIs(url, 'vimeo.com')) return null\n  const segments = url.pathname.split('/').filter(Boolean)\n  const at = segments.findIndex((segment) => /^\\d{5,}$/.test(segment))\n  if (at === -1) return null\n  const next = segments[at + 1]\n  const hash = url.searchParams.get('h') ?? (next && /^[\\da-f]{6,}$/i.test(next) ? next : undefined)\n  const time = url.hash.startsWith('#t=') ? url.hash.slice(1) : undefined\n  return { id: segments[at]!, hash, time }\n}\n\n/**\n * Вид слайда. Явний `type` виграє; без нього — за адресою: YouTube і Vimeo\n * мають власні плеєри, відеофайл — `<video>`, решта — зображення.\n */\nexport function lightboxKind(item: { type?: string; src: string }): LightboxKind {\n  if (item.type === 'custom' || item.type === 'iframe') return item.type\n  if (item.type === 'image') return 'image'\n  if (youtubeVideo(item.src)) return 'youtube'\n  if (vimeoVideo(item.src)) return 'vimeo'\n  if (item.type === 'video' || VIDEO_FILE.test(item.src)) return 'video'\n  return 'image'\n}\n\n/**\n * Адреса вбудованого плеєра.\n *\n * YouTube — через youtube-nocookie.com: плеєр не ставить cookies, доки\n * людина не натисне «відтворити», а галерея не має права вирішувати за\n * неї про трекінг. `autoplay` — бо слайд уже обрали явно; браузер однаково\n * дозволить звук лише після жесту користувача, а він щойно був.\n */\nexport function embedSrc(kind: LightboxKind, src: string): string {\n  if (kind === 'youtube') {\n    const video = youtubeVideo(src)\n    if (!video) return src\n    const start = video.start ? `&start=${video.start}` : ''\n    return `https://www.youtube-nocookie.com/embed/${video.id}?autoplay=1&rel=0&playsinline=1${start}`\n  }\n  if (kind === 'vimeo') {\n    const video = vimeoVideo(src)\n    if (!video) return src\n    const hash = video.hash ? `&h=${video.hash}` : ''\n    return `https://player.vimeo.com/video/${video.id}?autoplay=1&dnt=1${hash}${video.time ? `#${video.time}` : ''}`\n  }\n  return src\n}\n\n/**\n * Мініатюра для відео YouTube, коли власної немає. Для Vimeo такої\n * адреси без запиту до API не існує — там потрібен `thumbnail` чи `poster`.\n */\nexport function youtubeThumbnail(src: string): string | null {\n  const video = youtubeVideo(src)\n  return video ? `https://i.ytimg.com/vi/${video.id}/hqdefault.jpg` : null\n}\n\n/* ------------------------------------------------------------------ */\n/*  Геометрія збільшення                                               */\n/* ------------------------------------------------------------------ */\n\nexport interface Size {\n  width: number\n  height: number\n}\n\nexport interface Point {\n  x: number\n  y: number\n}\n\nexport interface Rect {\n  left: number\n  top: number\n  width: number\n  height: number\n}\n\nexport function clamp(value: number, min: number, max: number): number {\n  return Math.min(Math.max(value, min), max)\n}\n\n/** Чверть оберту (90°, 270°, −90°…): ширина й висота міняються місцями. */\nexport function isQuarterTurn(rotation: number): boolean {\n  return Math.abs(Math.round(rotation / 90)) % 2 === 1\n}\n\n/**\n * Масштаб «вписано» відносно розміру, який зображенню дав CSS.\n *\n * Без повороту CSS уже вписав зображення (`max-w-full max-h-full`) — це 1.\n * На чверть оберту ширина й висота міняються місцями, і повернуте фото\n * треба вписати заново: так само не більше за натуральний розмір, як це\n * робить CSS, інакше дрібне фото після повороту раптом розпливалося б.\n */\nexport function fitScale(input: { layout: Size; box: Size; natural?: Size; rotation: number }): number {\n  const { layout, box } = input\n  if (!isQuarterTurn(input.rotation)) return 1\n  if (!layout.width || !layout.height || !box.width || !box.height) return 1\n  const natural = input.natural?.width && input.natural.height ? input.natural : layout\n  const scaleOfNatural = Math.min(box.width / natural.height, box.height / natural.width, 1)\n  return (scaleOfNatural * natural.width) / layout.width\n}\n\n/**\n * Межі масштабу поточного зображення відносно розміру з CSS.\n *\n * Нижня — «вписано». Верхня — `maxZoom` від вписаного, але щонайменше\n * натуральний розмір: великий знімок має бути видно піксель у піксель,\n * навіть якщо для цього треба збільшити у вісім разів.\n */\nexport function zoomLimits(input: { base: number; naturalRatio: number; maxZoom: number }): { min: number; max: number } {\n  const min = input.base\n  const max = Math.max(input.base * Math.max(input.maxZoom, 1), input.naturalRatio, min)\n  return { min, max }\n}\n\n/**\n * Куди збільшувати кліком чи подвійним дотиком: до натурального розміру,\n * якщо фото велике, але щонайменше вдвічі — на дрібному фото збільшення в\n * 1.1 раза виглядало б як клік, що не спрацював.\n */\nexport function toggleZoomTarget(input: { base: number; naturalRatio: number; max: number }): number {\n  return clamp(Math.max(input.base * 2, input.naturalRatio), input.base, input.max)\n}\n\n/** Крок кнопок і клавіш `+`/`−`. */\nexport const ZOOM_STEP = 1.5\n\n/**\n * Наступний масштаб на крок. Майже вписане «доклацується» до вписаного:\n * інакше після кількох кроків туди й назад лишався б масштаб 1.02, за\n * якого зображення вже рухається, а стрілки ще не гортають.\n */\nexport function stepZoom(scale: number, direction: 1 | -1, limits: { min: number; max: number }): number {\n  const next = clamp(direction > 0 ? scale * ZOOM_STEP : scale / ZOOM_STEP, limits.min, limits.max)\n  return next < limits.min * 1.05 ? limits.min : next\n}\n\n/**\n * Найбільший зсув центру зображення, за якого край не відходить від краю\n * сцени. Менше за сцену — зсуву немає зовсім: зображення стоїть у центрі.\n */\nexport function panBounds(input: { layout: Size; stage: Size; scale: number; rotation: number }): Point {\n  const quarter = isQuarterTurn(input.rotation)\n  const width = (quarter ? input.layout.height : input.layout.width) * input.scale\n  const height = (quarter ? input.layout.width : input.layout.height) * input.scale\n  return {\n    x: Math.max(0, (width - input.stage.width) / 2),\n    y: Math.max(0, (height - input.stage.height) / 2),\n  }\n}\n\n/** Частка руху, що проходить за межу: край «пружинить», а не впирається. */\nexport const RUBBER_BAND = 0.3\n\n/** Гумовий край для зсуву: за межею `±limit` рух гаситься. */\nexport function rubberband(value: number, limit: number, factor = RUBBER_BAND): number {\n  if (value > limit) return limit + (value - limit) * factor\n  if (value < -limit) return -limit + (value + limit) * factor\n  return value\n}\n\n/** Гумові межі масштабу: щипок трохи за межу можливий, але з опором. */\nexport function rubberbandScale(scale: number, min: number, max: number, factor = RUBBER_BAND): number {\n  if (scale < min) return min - (min - scale) * factor\n  if (scale > max) return max + (scale - max) * factor\n  return scale\n}\n\n/**\n * Зсув після зміни масштабу, за якого точка під вказівником лишається на\n * місці. Точка й зсув — відносно центру сцени.\n *\n * Деталь під вказівником у координатах зображення — `(point − offset) /\n * scale`; щоб після збільшення вона лишилася під ним же, новий зсув має\n * бути `point − (point − offset) × nextScale / scale`.\n */\nexport function zoomAround(input: { point: Point; offset: Point; scale: number; nextScale: number }): Point {\n  const ratio = input.scale > 0 ? input.nextScale / input.scale : 1\n  return {\n    x: input.point.x - (input.point.x - input.offset.x) * ratio,\n    y: input.point.y - (input.point.y - input.offset.y) * ratio,\n  }\n}\n\n/**\n * Множник масштабу від одного руху колеса.\n *\n * Два різні пристрої під однією подією. Щипок на тачпаді приходить як\n * Ctrl + колесо з дрібними кроками по кілька пікселів — йому потрібен\n * чутливий коефіцієнт. Колесо миші дає ~100px на клацання — з тим самим\n * коефіцієнтом один клац збільшував би втричі.\n */\nexport function wheelZoomFactor(deltaY: number, deltaMode = 0, pinch = false, pageHeight = 800): number {\n  const pixels = deltaMode === 1 ? deltaY * 16 : deltaMode === 2 ? deltaY * pageHeight : deltaY\n  return clamp(Math.exp(-pixels * (pinch ? 0.01 : 0.002)), 0.5, 2)\n}\n\n/* ------------------------------------------------------------------ */\n/*  Інерція й дотики                                                   */\n/* ------------------------------------------------------------------ */\n\nexport interface PointerSample {\n  x: number\n  y: number\n  t: number\n}\n\n/**\n * Швидкість жесту в момент відпускання, px/мс, — за останні ~100 мс руху.\n * Уся історія жесту не годиться: повільний початок гасив би різкий змах\n * наприкінці, і зображення зупинялося б як укопане.\n */\nexport function releaseVelocity(samples: PointerSample[], windowMs = 100): Point {\n  const last = samples[samples.length - 1]\n  if (!last || samples.length < 2) return { x: 0, y: 0 }\n  let first = last\n  for (let index = samples.length - 2; index >= 0; index -= 1) {\n    const sample = samples[index]!\n    if (last.t - sample.t > windowMs) break\n    first = sample\n  }\n  const elapsed = last.t - first.t\n  if (elapsed <= 0) return { x: 0, y: 0 }\n  return { x: (last.x - first.x) / elapsed, y: (last.y - first.y) / elapsed }\n}\n\n/** Тертя інерції за мілісекунду: змах 1 px/мс докочується ще на ~200px. */\nexport const PAN_FRICTION = 0.995\n\n/** Швидкість після `elapsedMs` тертя. */\nexport function decay(velocity: number, elapsedMs: number, friction = PAN_FRICTION): number {\n  return velocity * friction ** elapsedMs\n}\n\n/** Скільки може зрушити палець, щоб дотик лишався дотиком, а не жестом. */\nexport const TAP_SLOP_PX = 10\n/** Найдовший дотик; довше — це вже натискання з утриманням. */\nexport const TAP_MAX_MS = 400\n/** Найбільша пауза між дотиками подвійного дотику. */\nexport const DOUBLE_TAP_MS = 300\n/** Наскільки далеко один від одного можуть бути дотики подвійного дотику. */\nexport const DOUBLE_TAP_SLOP_PX = 40\n\nexport function isTap(input: { dx: number; dy: number; elapsedMs: number }): boolean {\n  return Math.hypot(input.dx, input.dy) <= TAP_SLOP_PX && input.elapsedMs <= TAP_MAX_MS\n}\n\nexport function isDoubleTap(previous: PointerSample | null, next: PointerSample): boolean {\n  if (!previous) return false\n  return (\n    next.t - previous.t <= DOUBLE_TAP_MS\n    && Math.hypot(next.x - previous.x, next.y - previous.y) <= DOUBLE_TAP_SLOP_PX\n  )\n}\n\n/* ------------------------------------------------------------------ */\n/*  Закриття змахом                                                    */\n/* ------------------------------------------------------------------ */\n\n/**\n * Скільки треба протягнути, щоб відпущений слайд закрив галерею: 15%\n * висоти сцени, але не менше 80px — на низькому екрані в ландшафті 15%\n * давали б закриття від випадкового руху.\n */\nexport function closeThreshold(height: number): number {\n  if (!Number.isFinite(height) || height <= 0) return 80\n  return Math.max(80, Math.round(height * 0.15))\n}\n\n/**\n * Наскільки «закрита» галерея під пальцем: 0 — на місці, 1 — фон уже\n * зник. Фон гасне повільніше, ніж досягається поріг: людина має бачити,\n * що жест працює, ще до того, як його відпустила.\n */\nexport function closeProgress(dy: number, height: number): number {\n  return clamp(Math.abs(dy) / (closeThreshold(height) * 2.5), 0, 1)\n}\n\n/**\n * Чи закривати після відпускання: далеко протягнуто або різко змахнуто —\n * той самий флік, що гортає карусель (коротко, але швидко).\n */\nexport function shouldCloseOnDrag(input: { dy: number; elapsedMs: number; height: number; velocity?: number }): boolean {\n  const distance = Math.abs(input.dy)\n  if (distance >= closeThreshold(input.height)) return true\n  if (distance < 24) return false\n  return input.elapsedMs <= 200 || Math.abs(input.velocity ?? 0) >= 0.6\n}\n\n/* ------------------------------------------------------------------ */\n/*  Анімація з мініатюри                                               */\n/* ------------------------------------------------------------------ */\n\n/**\n * Перетворення, що ставить вписане зображення точно на місце мініатюри.\n *\n * `cover` — мініатюра обрізає фото (`object-cover`): масштаб береться за\n * більшою стороною, а те, що в мініатюру не влазить, ховає clip-path.\n * Відступи clip-path — у власних координатах зображення (до transform),\n * тому діляться на масштаб; радіус кутів — так само.\n */\nexport function originTransform(input: { image: Rect; thumbnail: Rect; fit: 'cover' | 'contain'; radius?: number }): {\n  x: number\n  y: number\n  scale: number\n  clipX: number\n  clipY: number\n  radius: number\n} {\n  const { image, thumbnail } = input\n  if (!image.width || !image.height) return { x: 0, y: 0, scale: 1, clipX: 0, clipY: 0, radius: 0 }\n  const scaleX = thumbnail.width / image.width\n  const scaleY = thumbnail.height / image.height\n  const cover = input.fit === 'cover'\n  const scale = cover ? Math.max(scaleX, scaleY) : Math.min(scaleX, scaleY)\n  return {\n    x: thumbnail.left + thumbnail.width / 2 - (image.left + image.width / 2),\n    y: thumbnail.top + thumbnail.height / 2 - (image.top + image.height / 2),\n    scale,\n    clipX: cover ? Math.max(0, (image.width - thumbnail.width / scale) / 2) : 0,\n    clipY: cover ? Math.max(0, (image.height - thumbnail.height / scale) / 2) : 0,\n    radius: scale > 0 ? (input.radius ?? 0) / scale : 0,\n  }\n}\n\n/**\n * Яка частка прямокутника лишається видимою після обрізання вікном і\n * предками з `overflow`. Мініатюра, прокручена за край каруселі, формально\n * у вікні, але її не видно — летіти туди зображенню не можна.\n */\nexport function visibleFraction(rect: Rect, clips: Rect[]): number {\n  const area = rect.width * rect.height\n  if (area <= 0) return 0\n  let left = rect.left\n  let top = rect.top\n  let right = rect.left + rect.width\n  let bottom = rect.top + rect.height\n  for (const clip of clips) {\n    left = Math.max(left, clip.left)\n    top = Math.max(top, clip.top)\n    right = Math.min(right, clip.left + clip.width)\n    bottom = Math.min(bottom, clip.top + clip.height)\n  }\n  return (Math.max(0, right - left) * Math.max(0, bottom - top)) / area\n}\n\n/* ------------------------------------------------------------------ */\n/*  Підписи                                                            */\n/* ------------------------------------------------------------------ */\n\n/** Вид слайда для підписів: скрінрідеру важливо, фото це чи відео. */\nexport type LightboxSlideKind = 'image' | 'video' | 'other'\n\nexport function slideKindOf(kind: LightboxKind): LightboxSlideKind {\n  if (kind === 'image') return 'image'\n  if (kind === 'video' || kind === 'youtube' || kind === 'vimeo') return 'video'\n  return 'other'\n}\n\n/**\n * Усі підписи галереї. Бібліотека i18n не має, але зашивати рядки в\n * компонент не можна — перекрити їх стало б неможливо (той самий підхід,\n * що в UiRichTextEditor).\n */\nexport interface LightboxLabels {\n  close: string\n  previous: string\n  next: string\n  zoomIn: string\n  zoomOut: string\n  rotateLeft: string\n  rotateRight: string\n  flipHorizontal: string\n  flipVertical: string\n  slideshowPlay: string\n  slideshowPause: string\n  fullscreenEnter: string\n  fullscreenExit: string\n  thumbnailsShow: string\n  thumbnailsHide: string\n  download: string\n  /** Назва групи мініатюр. */\n  thumbnails: string\n  loading: string\n  error: string\n  retry: string\n  empty: string\n  /** Оголошення поточного слайда: «Зображення 2 з 5: Хол». */\n  slide: (position: number, total: number, title: string, kind: LightboxSlideKind) => string\n  /** Назва мініатюри: «Зображення 2: Хол». */\n  thumbnail: (position: number, title: string, kind: LightboxSlideKind) => string\n}\n\nconst KIND_NOUN: Record<LightboxSlideKind, string> = { get image() { return uiText(\"Зображення\") }, get video() { return uiText(\"Відео\") }, get other() { return uiText(\"Слайд\") } }\n\nexport const LIGHTBOX_LABELS_UK: LightboxLabels = {\n  get close() { return uiText(\"Закрити\") },\n  get previous() { return uiText(\"Попередній слайд\") },\n  get next() { return uiText(\"Наступний слайд\") },\n  get zoomIn() { return uiText(\"Збільшити\") },\n  get zoomOut() { return uiText(\"Зменшити\") },\n  get rotateLeft() { return uiText(\"Повернути ліворуч\") },\n  get rotateRight() { return uiText(\"Повернути праворуч\") },\n  get flipHorizontal() { return uiText(\"Віддзеркалити по горизонталі\") },\n  get flipVertical() { return uiText(\"Віддзеркалити по вертикалі\") },\n  get slideshowPlay() { return uiText(\"Запустити слайдшоу\") },\n  get slideshowPause() { return uiText(\"Зупинити слайдшоу\") },\n  get fullscreenEnter() { return uiText(\"На весь екран\") },\n  get fullscreenExit() { return uiText(\"Вийти з повного екрана\") },\n  get thumbnailsShow() { return uiText(\"Показати мініатюри\") },\n  get thumbnailsHide() { return uiText(\"Сховати мініатюри\") },\n  get download() { return uiText(\"Завантажити\") },\n  get thumbnails() { return uiText(\"Мініатюри\") },\n  get loading() { return uiText(\"Завантаження\") },\n  get error() { return uiText(\"Не вдалося завантажити\") },\n  get retry() { return uiText(\"Спробувати ще раз\") },\n  get empty() { return uiText(\"Немає зображень\") },\n  slide: (position, total, title, kind) => uiText(\"{0} {1} з {2}: {3}\", { 0: KIND_NOUN[kind], 1: position, 2: total, 3: title }),\n  thumbnail: (position, title, kind) => `${KIND_NOUN[kind]} ${position}: ${title}`,\n}\n"
    }
  ]
}
