@layers-app/editor-video 0.1.1 → 0.1.3

package/dist/index.js

@@ -2,15 +2,16 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import { jsx, jsxs, Fragment } from "react/jsx-runtime";
-import { createContext, useState, useRef, useCallback, useMemo, useContext, useEffect, forwardRef, createElement, Children } from "react";
-import { createCommand, $getNodeByKey, $setSelection, DecoratorNode, $getSelection, $isNodeSelection, $createNodeSelection, $findMatchingParent, $isElementNode, CLICK_COMMAND, COMMAND_PRIORITY_LOW, FORMAT_ELEMENT_COMMAND, $isRangeSelection } from "lexical";
+import { createContext, useState, useRef, useCallback, useMemo, useContext, useEffect, forwardRef, createElement } from "react";
+import { createCommand, $getNodeByKey, $setSelection, COMMAND_PRIORITY_LOW, DecoratorNode } from "lexical";
 import { useTranslation } from "react-i18next";
-import { Tooltip, ActionIcon, Text, Progress, Paper, Button, TextInput, Loader, Menu, Box, Slider, Flex, Select, Switch, Stack, Group, Textarea, createSafeContext, factory, useProps, filterProps, rem, getSpacing, getBaseValue, InlineStyles, useMantineTheme, keys, getSortedBreakpoints, px, useStyles, createVarsResolver, useRandomClassName, useDirection, UnstyledButton, AccordionChevron, Modal, Divider } from "@mantine/core";
+import { Tooltip, ActionIcon, Text, Progress, Paper, Button, TextInput, Loader, Menu, Box, Slider, Flex, Select, Switch, Stack, Group, Textarea, Modal, Divider } from "@mantine/core";
+import { BlockWithAlignableContents } from "@lexical/react/LexicalBlockWithAlignableContents";
 import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
 import { Dropzone as Dropzone$1, IMAGE_MIME_TYPE } from "@mantine/dropzone";
 import ShakaPlayer from "shaka-player-react";
 import { IconDotsVertical, IconCheck, IconChevronLeft, IconChevronRight, IconHelpCircle } from "@tabler/icons-react";
-import { clamp as clamp$1 } from "@mantine/hooks";
+import { Carousel } from "@mantine/carousel";
 const VideoContext = createContext(null);
 function VideoPluginProvider({
   config,
@@ -49,12 +50,12 @@ function VideoPluginProvider({
       if (!(callbacks == null ? void 0 : callbacks.onError)) return;
       let apiError;
       if (error && typeof error === "object" && "status" in error && typeof error.status === "number") {
-        const e2 = error;
+        const e = error;
         apiError = {
-          status: e2.status,
-          statusText: e2.statusText || "",
-          message: e2.message || (e2.data && typeof e2.data === "object" && "message" in e2.data && typeof e2.data.message === "string" ? e2.data.message : "Request failed"),
-          data: e2.data,
+          status: e.status,
+          statusText: e.statusText || "",
+          message: e.message || (e.data && typeof e.data === "object" && "message" in e.data && typeof e.data.message === "string" ? e.data.message : "Request failed"),
+          data: e.data,
           source,
           videoId
         };
@@ -296,105 +297,6 @@ function removeVideoNode(editor, nodeKey, deleteNode) {
 function VideoToolbar({ children }) {
   return /* @__PURE__ */ jsx("div", { className: "media-actions", children });
 }
-class r extends DecoratorNode {
-  constructor(t, r2) {
-    super(r2);
-    __publicField(this, "__format");
-    this.__format = t || "";
-  }
-  exportJSON() {
-    return { ...super.exportJSON(), format: this.__format || "" };
-  }
-  updateFromJSON(t) {
-    return super.updateFromJSON(t).setFormat(t.format || "");
-  }
-  canIndent() {
-    return false;
-  }
-  createDOM() {
-    return document.createElement("div");
-  }
-  updateDOM() {
-    return false;
-  }
-  setFormat(t) {
-    const r2 = this.getWritable();
-    return r2.__format = t, r2;
-  }
-  isInline() {
-    return false;
-  }
-}
-function e(t) {
-  return t instanceof r;
-}
-function d(e2, t) {
-  return e2.getEditorState().read(() => {
-    const e3 = $getNodeByKey(t);
-    return null !== e3 && e3.isSelected();
-  });
-}
-function u(c) {
-  const [u2] = useLexicalComposerContext(), [p2, s] = useState(() => d(u2, c));
-  useEffect(() => {
-    let e2 = true;
-    const t = u2.registerUpdateListener(() => {
-      e2 && s(d(u2, c));
-    });
-    return () => {
-      e2 = false, t();
-    };
-  }, [u2, c]);
-  return [p2, useCallback((e2) => {
-    u2.update(() => {
-      let a = $getSelection();
-      $isNodeSelection(a) || (a = $createNodeSelection(), $setSelection(a)), $isNodeSelection(a) && (e2 ? a.add(c) : a.delete(c));
-    });
-  }, [u2, c]), useCallback(() => {
-    u2.update(() => {
-      const e2 = $getSelection();
-      $isNodeSelection(e2) && e2.clear();
-    });
-  }, [u2])];
-}
-function R(t, ...e2) {
-  const n = new URL("https://lexical.dev/docs/error"), o = new URLSearchParams();
-  o.append("code", t);
-  for (const t2 of e2) o.append("v", t2);
-  throw n.search = o.toString(), Error(`Minified Lexical error #${t}; visit ${n.toString()} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`);
-}
-const T = "undefined" != typeof window && void 0 !== window.document && void 0 !== window.document.createElement, B = T && "documentMode" in document ? document.documentMode : null;
-!(!T || !("InputEvent" in window) || B) && "getTargetRanges" in new window.InputEvent("input");
-function U(...t) {
-  return () => {
-    for (let e2 = t.length - 1; e2 >= 0; e2--) t[e2]();
-    t.length = 0;
-  };
-}
-function xt(t) {
-  const e2 = $findMatchingParent(t, (t2) => $isElementNode(t2) && !t2.isInline());
-  return $isElementNode(e2) || R(4, t.__key), e2;
-}
-function p({ children: p2, format: g, nodeKey: N, className: C }) {
-  const [h] = useLexicalComposerContext(), [v, y, F] = u(N), L = useRef(null);
-  return useEffect(() => U(h.registerCommand(FORMAT_ELEMENT_COMMAND, (e$1) => {
-    if (v) {
-      const r2 = $getSelection();
-      if ($isNodeSelection(r2)) {
-        const r3 = $getNodeByKey(N);
-        e(r3) && r3.setFormat(e$1);
-      } else if ($isRangeSelection(r2)) {
-        const o = r2.getNodes();
-        for (const r3 of o) if (e(r3)) r3.setFormat(e$1);
-        else {
-          xt(r3).setFormat(e$1);
-        }
-      }
-      return true;
-    }
-    return false;
-  }, COMMAND_PRIORITY_LOW), h.registerCommand(CLICK_COMMAND, (e2) => e2.target === L.current && (e2.preventDefault(), e2.shiftKey || F(), y(!v), true), COMMAND_PRIORITY_LOW)), [F, h, v, N, y]), jsx("div", { className: [C.base, v ? C.focus : null].filter(Boolean).join(" "), ref: L, style: { textAlign: g || void 0 }, children: p2 });
-}
 function StarsAnimation({ size = 32 }) {
   return /* @__PURE__ */ jsx(
     "div",
@@ -1011,9 +913,9 @@ async function uploadChunkWithProgress(videoId, file, offset, end, total, baseUr
         reject(new Error("Upload cancelled"));
       });
     }
-    xhr.upload.addEventListener("progress", (e2) => {
-      if (e2.lengthComputable && onProgress) {
-        onProgress(e2.loaded);
+    xhr.upload.addEventListener("progress", (e) => {
+      if (e.lengthComputable && onProgress) {
+        onProgress(e.loaded);
       }
     });
     xhr.addEventListener("load", () => {
@@ -2177,11 +2079,11 @@ function LinkState({
   onSubmit
 }) {
   const { t } = useTranslation();
-  const stopMousePropagation = useCallback((e2) => {
-    e2.stopPropagation();
+  const stopMousePropagation = useCallback((e) => {
+    e.stopPropagation();
   }, []);
-  const stopPointerPropagation = useCallback((e2) => {
-    e2.stopPropagation();
+  const stopPointerPropagation = useCallback((e) => {
+    e.stopPropagation();
   }, []);
   return /* @__PURE__ */ jsxs(
     "div",
@@ -3840,8 +3742,8 @@ function VideoPlayerState({
     if (errorHandlerRef.current) {
       try {
         player.removeEventListener("error", errorHandlerRef.current);
-      } catch (e2) {
-        console.warn("Error removing old event listener:", e2);
+      } catch (e) {
+        console.warn("Error removing old event listener:", e);
       }
     }
     const errorHandler = (event) => {
@@ -3870,8 +3772,8 @@ function VideoPlayerState({
       if (player && errorHandlerRef.current) {
         try {
           player.removeEventListener("error", errorHandlerRef.current);
-        } catch (e2) {
-          console.warn("Error removing event listener on cleanup:", e2);
+        } catch (e) {
+          console.warn("Error removing event listener on cleanup:", e);
         }
       }
     };
@@ -4929,7 +4831,7 @@ function VideoUploadComponent({
     }
   };
   return /* @__PURE__ */ jsx(
-    p,
+    BlockWithAlignableContents,
     {
       className,
       format,
@@ -4945,9 +4847,9 @@ function VideoUploadComponent({
               "div",
               {
                 className: "video-upload-header",
-                onClick: (e2) => e2.stopPropagation(),
-                onMouseDown: (e2) => e2.stopPropagation(),
-                onPointerDown: (e2) => e2.stopPropagation(),
+                onClick: (e) => e.stopPropagation(),
+                onMouseDown: (e) => e.stopPropagation(),
+                onPointerDown: (e) => e.stopPropagation(),
                 children: /* @__PURE__ */ jsx(
                   Select,
                   {
@@ -5224,7 +5126,7 @@ function ChapterRow({
                   variant: "default",
                   placeholder: startTimePlaceholder,
                   value: startInput,
-                  onChange: (e2) => handleStartChange(e2.currentTarget.value),
+                  onChange: (e) => handleStartChange(e.currentTarget.value),
                   style: { width: "100%" },
                   styles: {
                     input: {
@@ -5250,7 +5152,7 @@ function ChapterRow({
                   variant: "default",
                   placeholder: endTimePlaceholder,
                   value: endInput,
-                  onChange: (e2) => handleEndChange(e2.currentTarget.value),
+                  onChange: (e) => handleEndChange(e.currentTarget.value),
                   style: { width: "100%" },
                   styles: {
                     input: {
@@ -5285,7 +5187,7 @@ function ChapterRow({
                 variant: "default",
                 placeholder: titlePlaceholder,
                 value: chapter.title,
-                onChange: (e2) => onTitleChange(index, e2.currentTarget.value),
+                onChange: (e) => onTitleChange(index, e.currentTarget.value),
                 styles: {
                   root: {
                     width: "100%",
@@ -5390,8 +5292,8 @@ function ChaptersSection({
       return;
     }
     const updateDuration = () => {
-      const d2 = nativeVideo.duration;
-      setDurationSec(Number.isFinite(d2) && d2 > 0 ? d2 : null);
+      const d = nativeVideo.duration;
+      setDurationSec(Number.isFinite(d) && d > 0 ? d : null);
     };
     updateDuration();
     nativeVideo.addEventListener("loadedmetadata", updateDuration);
@@ -5583,8 +5485,8 @@ function ChaptersSection({
           size: "sm",
           color: "var(--mantine-primary-color-filled)",
           checked: chaptersDisabled,
-          onChange: (e2) => {
-            const disabled2 = e2.currentTarget.checked;
+          onChange: (e) => {
+            const disabled2 = e.currentTarget.checked;
             onChaptersDisabledChange(disabled2);
             if (disabled2 && autoChaptersEnabled) {
               onAutoChaptersChange(false);
@@ -5602,8 +5504,8 @@ function ChaptersSection({
           color: "var(--mantine-primary-color-filled)",
           checked: autoChaptersEnabled,
           disabled: chaptersDisabled,
-          onChange: (e2) => {
-            const enabled = e2.currentTarget.checked;
+          onChange: (e) => {
+            const enabled = e.currentTarget.checked;
             onAutoChaptersChange(enabled);
             if (enabled) {
               handleSuggest();
@@ -5670,2053 +5572,6 @@ function ChaptersSection({
     editableChapters.length === 0 && !isLoading && /* @__PURE__ */ jsx(Text, { size: "xs", c: "dimmed", mt: "xs", children: emptyLabel })
   ] });
 }
-function isObject$1(subject) {
-  return Object.prototype.toString.call(subject) === "[object Object]";
-}
-function isRecord(subject) {
-  return isObject$1(subject) || Array.isArray(subject);
-}
-function canUseDOM() {
-  return !!(typeof window !== "undefined" && window.document && window.document.createElement);
-}
-function areOptionsEqual(optionsA, optionsB) {
-  const optionsAKeys = Object.keys(optionsA);
-  const optionsBKeys = Object.keys(optionsB);
-  if (optionsAKeys.length !== optionsBKeys.length) return false;
-  const breakpointsA = JSON.stringify(Object.keys(optionsA.breakpoints || {}));
-  const breakpointsB = JSON.stringify(Object.keys(optionsB.breakpoints || {}));
-  if (breakpointsA !== breakpointsB) return false;
-  return optionsAKeys.every((key) => {
-    const valueA = optionsA[key];
-    const valueB = optionsB[key];
-    if (typeof valueA === "function") return `${valueA}` === `${valueB}`;
-    if (!isRecord(valueA) || !isRecord(valueB)) return valueA === valueB;
-    return areOptionsEqual(valueA, valueB);
-  });
-}
-function sortAndMapPluginToOptions(plugins) {
-  return plugins.concat().sort((a, b) => a.name > b.name ? 1 : -1).map((plugin) => plugin.options);
-}
-function arePluginsEqual(pluginsA, pluginsB) {
-  if (pluginsA.length !== pluginsB.length) return false;
-  const optionsA = sortAndMapPluginToOptions(pluginsA);
-  const optionsB = sortAndMapPluginToOptions(pluginsB);
-  return optionsA.every((optionA, index) => {
-    const optionB = optionsB[index];
-    return areOptionsEqual(optionA, optionB);
-  });
-}
-function isNumber(subject) {
-  return typeof subject === "number";
-}
-function isString(subject) {
-  return typeof subject === "string";
-}
-function isBoolean(subject) {
-  return typeof subject === "boolean";
-}
-function isObject(subject) {
-  return Object.prototype.toString.call(subject) === "[object Object]";
-}
-function mathAbs(n) {
-  return Math.abs(n);
-}
-function mathSign(n) {
-  return Math.sign(n);
-}
-function deltaAbs(valueB, valueA) {
-  return mathAbs(valueB - valueA);
-}
-function factorAbs(valueB, valueA) {
-  if (valueB === 0 || valueA === 0) return 0;
-  if (mathAbs(valueB) <= mathAbs(valueA)) return 0;
-  const diff = deltaAbs(mathAbs(valueB), mathAbs(valueA));
-  return mathAbs(diff / valueB);
-}
-function roundToTwoDecimals(num) {
-  return Math.round(num * 100) / 100;
-}
-function arrayKeys(array) {
-  return objectKeys(array).map(Number);
-}
-function arrayLast(array) {
-  return array[arrayLastIndex(array)];
-}
-function arrayLastIndex(array) {
-  return Math.max(0, array.length - 1);
-}
-function arrayIsLastIndex(array, index) {
-  return index === arrayLastIndex(array);
-}
-function arrayFromNumber(n, startAt = 0) {
-  return Array.from(Array(n), (_, i) => startAt + i);
-}
-function objectKeys(object) {
-  return Object.keys(object);
-}
-function objectsMergeDeep(objectA, objectB) {
-  return [objectA, objectB].reduce((mergedObjects, currentObject) => {
-    objectKeys(currentObject).forEach((key) => {
-      const valueA = mergedObjects[key];
-      const valueB = currentObject[key];
-      const areObjects = isObject(valueA) && isObject(valueB);
-      mergedObjects[key] = areObjects ? objectsMergeDeep(valueA, valueB) : valueB;
-    });
-    return mergedObjects;
-  }, {});
-}
-function isMouseEvent(evt, ownerWindow) {
-  return typeof ownerWindow.MouseEvent !== "undefined" && evt instanceof ownerWindow.MouseEvent;
-}
-function Alignment(align, viewSize) {
-  const predefined = {
-    start,
-    center,
-    end
-  };
-  function start() {
-    return 0;
-  }
-  function center(n) {
-    return end(n) / 2;
-  }
-  function end(n) {
-    return viewSize - n;
-  }
-  function measure(n, index) {
-    if (isString(align)) return predefined[align](n);
-    return align(viewSize, n, index);
-  }
-  const self = {
-    measure
-  };
-  return self;
-}
-function EventStore() {
-  let listeners = [];
-  function add(node, type, handler, options = {
-    passive: true
-  }) {
-    let removeListener;
-    if ("addEventListener" in node) {
-      node.addEventListener(type, handler, options);
-      removeListener = () => node.removeEventListener(type, handler, options);
-    } else {
-      const legacyMediaQueryList = node;
-      legacyMediaQueryList.addListener(handler);
-      removeListener = () => legacyMediaQueryList.removeListener(handler);
-    }
-    listeners.push(removeListener);
-    return self;
-  }
-  function clear() {
-    listeners = listeners.filter((remove) => remove());
-  }
-  const self = {
-    add,
-    clear
-  };
-  return self;
-}
-function Animations(ownerDocument, ownerWindow, update, render) {
-  const documentVisibleHandler = EventStore();
-  const fixedTimeStep = 1e3 / 60;
-  let lastTimeStamp = null;
-  let accumulatedTime = 0;
-  let animationId = 0;
-  function init() {
-    documentVisibleHandler.add(ownerDocument, "visibilitychange", () => {
-      if (ownerDocument.hidden) reset();
-    });
-  }
-  function destroy() {
-    stop();
-    documentVisibleHandler.clear();
-  }
-  function animate(timeStamp) {
-    if (!animationId) return;
-    if (!lastTimeStamp) {
-      lastTimeStamp = timeStamp;
-      update();
-      update();
-    }
-    const timeElapsed = timeStamp - lastTimeStamp;
-    lastTimeStamp = timeStamp;
-    accumulatedTime += timeElapsed;
-    while (accumulatedTime >= fixedTimeStep) {
-      update();
-      accumulatedTime -= fixedTimeStep;
-    }
-    const alpha = accumulatedTime / fixedTimeStep;
-    render(alpha);
-    if (animationId) {
-      animationId = ownerWindow.requestAnimationFrame(animate);
-    }
-  }
-  function start() {
-    if (animationId) return;
-    animationId = ownerWindow.requestAnimationFrame(animate);
-  }
-  function stop() {
-    ownerWindow.cancelAnimationFrame(animationId);
-    lastTimeStamp = null;
-    accumulatedTime = 0;
-    animationId = 0;
-  }
-  function reset() {
-    lastTimeStamp = null;
-    accumulatedTime = 0;
-  }
-  const self = {
-    init,
-    destroy,
-    start,
-    stop,
-    update,
-    render
-  };
-  return self;
-}
-function Axis(axis, contentDirection) {
-  const isRightToLeft = contentDirection === "rtl";
-  const isVertical = axis === "y";
-  const scroll = isVertical ? "y" : "x";
-  const cross = isVertical ? "x" : "y";
-  const sign = !isVertical && isRightToLeft ? -1 : 1;
-  const startEdge = getStartEdge();
-  const endEdge = getEndEdge();
-  function measureSize(nodeRect) {
-    const {
-      height,
-      width
-    } = nodeRect;
-    return isVertical ? height : width;
-  }
-  function getStartEdge() {
-    if (isVertical) return "top";
-    return isRightToLeft ? "right" : "left";
-  }
-  function getEndEdge() {
-    if (isVertical) return "bottom";
-    return isRightToLeft ? "left" : "right";
-  }
-  function direction(n) {
-    return n * sign;
-  }
-  const self = {
-    scroll,
-    cross,
-    startEdge,
-    endEdge,
-    measureSize,
-    direction
-  };
-  return self;
-}
-function Limit(min = 0, max = 0) {
-  const length = mathAbs(min - max);
-  function reachedMin(n) {
-    return n < min;
-  }
-  function reachedMax(n) {
-    return n > max;
-  }
-  function reachedAny(n) {
-    return reachedMin(n) || reachedMax(n);
-  }
-  function constrain(n) {
-    if (!reachedAny(n)) return n;
-    return reachedMin(n) ? min : max;
-  }
-  function removeOffset(n) {
-    if (!length) return n;
-    return n - length * Math.ceil((n - max) / length);
-  }
-  const self = {
-    length,
-    max,
-    min,
-    constrain,
-    reachedAny,
-    reachedMax,
-    reachedMin,
-    removeOffset
-  };
-  return self;
-}
-function Counter(max, start, loop) {
-  const {
-    constrain
-  } = Limit(0, max);
-  const loopEnd = max + 1;
-  let counter = withinLimit(start);
-  function withinLimit(n) {
-    return !loop ? constrain(n) : mathAbs((loopEnd + n) % loopEnd);
-  }
-  function get() {
-    return counter;
-  }
-  function set(n) {
-    counter = withinLimit(n);
-    return self;
-  }
-  function add(n) {
-    return clone().set(get() + n);
-  }
-  function clone() {
-    return Counter(max, get(), loop);
-  }
-  const self = {
-    get,
-    set,
-    add,
-    clone
-  };
-  return self;
-}
-function DragHandler(axis, rootNode, ownerDocument, ownerWindow, target, dragTracker, location, animation, scrollTo, scrollBody, scrollTarget, index, eventHandler, percentOfView, dragFree, dragThreshold, skipSnaps, baseFriction, watchDrag) {
-  const {
-    cross: crossAxis,
-    direction
-  } = axis;
-  const focusNodes = ["INPUT", "SELECT", "TEXTAREA"];
-  const nonPassiveEvent = {
-    passive: false
-  };
-  const initEvents = EventStore();
-  const dragEvents = EventStore();
-  const goToNextThreshold = Limit(50, 225).constrain(percentOfView.measure(20));
-  const snapForceBoost = {
-    mouse: 300,
-    touch: 400
-  };
-  const freeForceBoost = {
-    mouse: 500,
-    touch: 600
-  };
-  const baseSpeed = dragFree ? 43 : 25;
-  let isMoving = false;
-  let startScroll = 0;
-  let startCross = 0;
-  let pointerIsDown = false;
-  let preventScroll = false;
-  let preventClick = false;
-  let isMouse = false;
-  function init(emblaApi) {
-    if (!watchDrag) return;
-    function downIfAllowed(evt) {
-      if (isBoolean(watchDrag) || watchDrag(emblaApi, evt)) down(evt);
-    }
-    const node = rootNode;
-    initEvents.add(node, "dragstart", (evt) => evt.preventDefault(), nonPassiveEvent).add(node, "touchmove", () => void 0, nonPassiveEvent).add(node, "touchend", () => void 0).add(node, "touchstart", downIfAllowed).add(node, "mousedown", downIfAllowed).add(node, "touchcancel", up).add(node, "contextmenu", up).add(node, "click", click, true);
-  }
-  function destroy() {
-    initEvents.clear();
-    dragEvents.clear();
-  }
-  function addDragEvents() {
-    const node = isMouse ? ownerDocument : rootNode;
-    dragEvents.add(node, "touchmove", move, nonPassiveEvent).add(node, "touchend", up).add(node, "mousemove", move, nonPassiveEvent).add(node, "mouseup", up);
-  }
-  function isFocusNode(node) {
-    const nodeName = node.nodeName || "";
-    return focusNodes.includes(nodeName);
-  }
-  function forceBoost() {
-    const boost = dragFree ? freeForceBoost : snapForceBoost;
-    const type = isMouse ? "mouse" : "touch";
-    return boost[type];
-  }
-  function allowedForce(force, targetChanged) {
-    const next = index.add(mathSign(force) * -1);
-    const baseForce = scrollTarget.byDistance(force, !dragFree).distance;
-    if (dragFree || mathAbs(force) < goToNextThreshold) return baseForce;
-    if (skipSnaps && targetChanged) return baseForce * 0.5;
-    return scrollTarget.byIndex(next.get(), 0).distance;
-  }
-  function down(evt) {
-    const isMouseEvt = isMouseEvent(evt, ownerWindow);
-    isMouse = isMouseEvt;
-    preventClick = dragFree && isMouseEvt && !evt.buttons && isMoving;
-    isMoving = deltaAbs(target.get(), location.get()) >= 2;
-    if (isMouseEvt && evt.button !== 0) return;
-    if (isFocusNode(evt.target)) return;
-    pointerIsDown = true;
-    dragTracker.pointerDown(evt);
-    scrollBody.useFriction(0).useDuration(0);
-    target.set(location);
-    addDragEvents();
-    startScroll = dragTracker.readPoint(evt);
-    startCross = dragTracker.readPoint(evt, crossAxis);
-    eventHandler.emit("pointerDown");
-  }
-  function move(evt) {
-    const isTouchEvt = !isMouseEvent(evt, ownerWindow);
-    if (isTouchEvt && evt.touches.length >= 2) return up(evt);
-    const lastScroll = dragTracker.readPoint(evt);
-    const lastCross = dragTracker.readPoint(evt, crossAxis);
-    const diffScroll = deltaAbs(lastScroll, startScroll);
-    const diffCross = deltaAbs(lastCross, startCross);
-    if (!preventScroll && !isMouse) {
-      if (!evt.cancelable) return up(evt);
-      preventScroll = diffScroll > diffCross;
-      if (!preventScroll) return up(evt);
-    }
-    const diff = dragTracker.pointerMove(evt);
-    if (diffScroll > dragThreshold) preventClick = true;
-    scrollBody.useFriction(0.3).useDuration(0.75);
-    animation.start();
-    target.add(direction(diff));
-    evt.preventDefault();
-  }
-  function up(evt) {
-    const currentLocation = scrollTarget.byDistance(0, false);
-    const targetChanged = currentLocation.index !== index.get();
-    const rawForce = dragTracker.pointerUp(evt) * forceBoost();
-    const force = allowedForce(direction(rawForce), targetChanged);
-    const forceFactor = factorAbs(rawForce, force);
-    const speed = baseSpeed - 10 * forceFactor;
-    const friction = baseFriction + forceFactor / 50;
-    preventScroll = false;
-    pointerIsDown = false;
-    dragEvents.clear();
-    scrollBody.useDuration(speed).useFriction(friction);
-    scrollTo.distance(force, !dragFree);
-    isMouse = false;
-    eventHandler.emit("pointerUp");
-  }
-  function click(evt) {
-    if (preventClick) {
-      evt.stopPropagation();
-      evt.preventDefault();
-      preventClick = false;
-    }
-  }
-  function pointerDown() {
-    return pointerIsDown;
-  }
-  const self = {
-    init,
-    destroy,
-    pointerDown
-  };
-  return self;
-}
-function DragTracker(axis, ownerWindow) {
-  const logInterval = 170;
-  let startEvent;
-  let lastEvent;
-  function readTime(evt) {
-    return evt.timeStamp;
-  }
-  function readPoint(evt, evtAxis) {
-    const property = evtAxis || axis.scroll;
-    const coord = `client${property === "x" ? "X" : "Y"}`;
-    return (isMouseEvent(evt, ownerWindow) ? evt : evt.touches[0])[coord];
-  }
-  function pointerDown(evt) {
-    startEvent = evt;
-    lastEvent = evt;
-    return readPoint(evt);
-  }
-  function pointerMove(evt) {
-    const diff = readPoint(evt) - readPoint(lastEvent);
-    const expired = readTime(evt) - readTime(startEvent) > logInterval;
-    lastEvent = evt;
-    if (expired) startEvent = evt;
-    return diff;
-  }
-  function pointerUp(evt) {
-    if (!startEvent || !lastEvent) return 0;
-    const diffDrag = readPoint(lastEvent) - readPoint(startEvent);
-    const diffTime = readTime(evt) - readTime(startEvent);
-    const expired = readTime(evt) - readTime(lastEvent) > logInterval;
-    const force = diffDrag / diffTime;
-    const isFlick = diffTime && !expired && mathAbs(force) > 0.1;
-    return isFlick ? force : 0;
-  }
-  const self = {
-    pointerDown,
-    pointerMove,
-    pointerUp,
-    readPoint
-  };
-  return self;
-}
-function NodeRects() {
-  function measure(node) {
-    const {
-      offsetTop,
-      offsetLeft,
-      offsetWidth,
-      offsetHeight
-    } = node;
-    const offset = {
-      top: offsetTop,
-      right: offsetLeft + offsetWidth,
-      bottom: offsetTop + offsetHeight,
-      left: offsetLeft,
-      width: offsetWidth,
-      height: offsetHeight
-    };
-    return offset;
-  }
-  const self = {
-    measure
-  };
-  return self;
-}
-function PercentOfView(viewSize) {
-  function measure(n) {
-    return viewSize * (n / 100);
-  }
-  const self = {
-    measure
-  };
-  return self;
-}
-function ResizeHandler(container, eventHandler, ownerWindow, slides, axis, watchResize, nodeRects) {
-  const observeNodes = [container].concat(slides);
-  let resizeObserver;
-  let containerSize;
-  let slideSizes = [];
-  let destroyed = false;
-  function readSize(node) {
-    return axis.measureSize(nodeRects.measure(node));
-  }
-  function init(emblaApi) {
-    if (!watchResize) return;
-    containerSize = readSize(container);
-    slideSizes = slides.map(readSize);
-    function defaultCallback(entries) {
-      for (const entry of entries) {
-        if (destroyed) return;
-        const isContainer = entry.target === container;
-        const slideIndex = slides.indexOf(entry.target);
-        const lastSize = isContainer ? containerSize : slideSizes[slideIndex];
-        const newSize = readSize(isContainer ? container : slides[slideIndex]);
-        const diffSize = mathAbs(newSize - lastSize);
-        if (diffSize >= 0.5) {
-          emblaApi.reInit();
-          eventHandler.emit("resize");
-          break;
-        }
-      }
-    }
-    resizeObserver = new ResizeObserver((entries) => {
-      if (isBoolean(watchResize) || watchResize(emblaApi, entries)) {
-        defaultCallback(entries);
-      }
-    });
-    ownerWindow.requestAnimationFrame(() => {
-      observeNodes.forEach((node) => resizeObserver.observe(node));
-    });
-  }
-  function destroy() {
-    destroyed = true;
-    if (resizeObserver) resizeObserver.disconnect();
-  }
-  const self = {
-    init,
-    destroy
-  };
-  return self;
-}
-function ScrollBody(location, offsetLocation, previousLocation, target, baseDuration, baseFriction) {
-  let scrollVelocity = 0;
-  let scrollDirection = 0;
-  let scrollDuration = baseDuration;
-  let scrollFriction = baseFriction;
-  let rawLocation = location.get();
-  let rawLocationPrevious = 0;
-  function seek() {
-    const displacement = target.get() - location.get();
-    const isInstant = !scrollDuration;
-    let scrollDistance = 0;
-    if (isInstant) {
-      scrollVelocity = 0;
-      previousLocation.set(target);
-      location.set(target);
-      scrollDistance = displacement;
-    } else {
-      previousLocation.set(location);
-      scrollVelocity += displacement / scrollDuration;
-      scrollVelocity *= scrollFriction;
-      rawLocation += scrollVelocity;
-      location.add(scrollVelocity);
-      scrollDistance = rawLocation - rawLocationPrevious;
-    }
-    scrollDirection = mathSign(scrollDistance);
-    rawLocationPrevious = rawLocation;
-    return self;
-  }
-  function settled() {
-    const diff = target.get() - offsetLocation.get();
-    return mathAbs(diff) < 1e-3;
-  }
-  function duration() {
-    return scrollDuration;
-  }
-  function direction() {
-    return scrollDirection;
-  }
-  function velocity() {
-    return scrollVelocity;
-  }
-  function useBaseDuration() {
-    return useDuration(baseDuration);
-  }
-  function useBaseFriction() {
-    return useFriction(baseFriction);
-  }
-  function useDuration(n) {
-    scrollDuration = n;
-    return self;
-  }
-  function useFriction(n) {
-    scrollFriction = n;
-    return self;
-  }
-  const self = {
-    direction,
-    duration,
-    velocity,
-    seek,
-    settled,
-    useBaseFriction,
-    useBaseDuration,
-    useFriction,
-    useDuration
-  };
-  return self;
-}
-function ScrollBounds(limit, location, target, scrollBody, percentOfView) {
-  const pullBackThreshold = percentOfView.measure(10);
-  const edgeOffsetTolerance = percentOfView.measure(50);
-  const frictionLimit = Limit(0.1, 0.99);
-  let disabled2 = false;
-  function shouldConstrain() {
-    if (disabled2) return false;
-    if (!limit.reachedAny(target.get())) return false;
-    if (!limit.reachedAny(location.get())) return false;
-    return true;
-  }
-  function constrain(pointerDown) {
-    if (!shouldConstrain()) return;
-    const edge = limit.reachedMin(location.get()) ? "min" : "max";
-    const diffToEdge = mathAbs(limit[edge] - location.get());
-    const diffToTarget = target.get() - location.get();
-    const friction = frictionLimit.constrain(diffToEdge / edgeOffsetTolerance);
-    target.subtract(diffToTarget * friction);
-    if (!pointerDown && mathAbs(diffToTarget) < pullBackThreshold) {
-      target.set(limit.constrain(target.get()));
-      scrollBody.useDuration(25).useBaseFriction();
-    }
-  }
-  function toggleActive(active) {
-    disabled2 = !active;
-  }
-  const self = {
-    shouldConstrain,
-    constrain,
-    toggleActive
-  };
-  return self;
-}
-function ScrollContain(viewSize, contentSize, snapsAligned, containScroll, pixelTolerance) {
-  const scrollBounds = Limit(-contentSize + viewSize, 0);
-  const snapsBounded = measureBounded();
-  const scrollContainLimit = findScrollContainLimit();
-  const snapsContained = measureContained();
-  function usePixelTolerance(bound, snap) {
-    return deltaAbs(bound, snap) <= 1;
-  }
-  function findScrollContainLimit() {
-    const startSnap = snapsBounded[0];
-    const endSnap = arrayLast(snapsBounded);
-    const min = snapsBounded.lastIndexOf(startSnap);
-    const max = snapsBounded.indexOf(endSnap) + 1;
-    return Limit(min, max);
-  }
-  function measureBounded() {
-    return snapsAligned.map((snapAligned, index) => {
-      const {
-        min,
-        max
-      } = scrollBounds;
-      const snap = scrollBounds.constrain(snapAligned);
-      const isFirst = !index;
-      const isLast = arrayIsLastIndex(snapsAligned, index);
-      if (isFirst) return max;
-      if (isLast) return min;
-      if (usePixelTolerance(min, snap)) return min;
-      if (usePixelTolerance(max, snap)) return max;
-      return snap;
-    }).map((scrollBound) => parseFloat(scrollBound.toFixed(3)));
-  }
-  function measureContained() {
-    if (contentSize <= viewSize + pixelTolerance) return [scrollBounds.max];
-    if (containScroll === "keepSnaps") return snapsBounded;
-    const {
-      min,
-      max
-    } = scrollContainLimit;
-    return snapsBounded.slice(min, max);
-  }
-  const self = {
-    snapsContained,
-    scrollContainLimit
-  };
-  return self;
-}
-function ScrollLimit(contentSize, scrollSnaps, loop) {
-  const max = scrollSnaps[0];
-  const min = loop ? max - contentSize : arrayLast(scrollSnaps);
-  const limit = Limit(min, max);
-  const self = {
-    limit
-  };
-  return self;
-}
-function ScrollLooper(contentSize, limit, location, vectors) {
-  const jointSafety = 0.1;
-  const min = limit.min + jointSafety;
-  const max = limit.max + jointSafety;
-  const {
-    reachedMin,
-    reachedMax
-  } = Limit(min, max);
-  function shouldLoop(direction) {
-    if (direction === 1) return reachedMax(location.get());
-    if (direction === -1) return reachedMin(location.get());
-    return false;
-  }
-  function loop(direction) {
-    if (!shouldLoop(direction)) return;
-    const loopDistance = contentSize * (direction * -1);
-    vectors.forEach((v) => v.add(loopDistance));
-  }
-  const self = {
-    loop
-  };
-  return self;
-}
-function ScrollProgress(limit) {
-  const {
-    max,
-    length
-  } = limit;
-  function get(n) {
-    const currentLocation = n - max;
-    return length ? currentLocation / -length : 0;
-  }
-  const self = {
-    get
-  };
-  return self;
-}
-function ScrollSnaps(axis, alignment, containerRect, slideRects, slidesToScroll) {
-  const {
-    startEdge,
-    endEdge
-  } = axis;
-  const {
-    groupSlides
-  } = slidesToScroll;
-  const alignments = measureSizes().map(alignment.measure);
-  const snaps = measureUnaligned();
-  const snapsAligned = measureAligned();
-  function measureSizes() {
-    return groupSlides(slideRects).map((rects) => arrayLast(rects)[endEdge] - rects[0][startEdge]).map(mathAbs);
-  }
-  function measureUnaligned() {
-    return slideRects.map((rect) => containerRect[startEdge] - rect[startEdge]).map((snap) => -mathAbs(snap));
-  }
-  function measureAligned() {
-    return groupSlides(snaps).map((g) => g[0]).map((snap, index) => snap + alignments[index]);
-  }
-  const self = {
-    snaps,
-    snapsAligned
-  };
-  return self;
-}
-function SlideRegistry(containSnaps, containScroll, scrollSnaps, scrollContainLimit, slidesToScroll, slideIndexes) {
-  const {
-    groupSlides
-  } = slidesToScroll;
-  const {
-    min,
-    max
-  } = scrollContainLimit;
-  const slideRegistry = createSlideRegistry();
-  function createSlideRegistry() {
-    const groupedSlideIndexes = groupSlides(slideIndexes);
-    const doNotContain = !containSnaps || containScroll === "keepSnaps";
-    if (scrollSnaps.length === 1) return [slideIndexes];
-    if (doNotContain) return groupedSlideIndexes;
-    return groupedSlideIndexes.slice(min, max).map((group, index, groups) => {
-      const isFirst = !index;
-      const isLast = arrayIsLastIndex(groups, index);
-      if (isFirst) {
-        const range = arrayLast(groups[0]) + 1;
-        return arrayFromNumber(range);
-      }
-      if (isLast) {
-        const range = arrayLastIndex(slideIndexes) - arrayLast(groups)[0] + 1;
-        return arrayFromNumber(range, arrayLast(groups)[0]);
-      }
-      return group;
-    });
-  }
-  const self = {
-    slideRegistry
-  };
-  return self;
-}
-function ScrollTarget(loop, scrollSnaps, contentSize, limit, targetVector) {
-  const {
-    reachedAny,
-    removeOffset,
-    constrain
-  } = limit;
-  function minDistance(distances) {
-    return distances.concat().sort((a, b) => mathAbs(a) - mathAbs(b))[0];
-  }
-  function findTargetSnap(target) {
-    const distance = loop ? removeOffset(target) : constrain(target);
-    const ascDiffsToSnaps = scrollSnaps.map((snap, index2) => ({
-      diff: shortcut(snap - distance, 0),
-      index: index2
-    })).sort((d1, d2) => mathAbs(d1.diff) - mathAbs(d2.diff));
-    const {
-      index
-    } = ascDiffsToSnaps[0];
-    return {
-      index,
-      distance
-    };
-  }
-  function shortcut(target, direction) {
-    const targets = [target, target + contentSize, target - contentSize];
-    if (!loop) return target;
-    if (!direction) return minDistance(targets);
-    const matchingTargets = targets.filter((t) => mathSign(t) === direction);
-    if (matchingTargets.length) return minDistance(matchingTargets);
-    return arrayLast(targets) - contentSize;
-  }
-  function byIndex(index, direction) {
-    const diffToSnap = scrollSnaps[index] - targetVector.get();
-    const distance = shortcut(diffToSnap, direction);
-    return {
-      index,
-      distance
-    };
-  }
-  function byDistance(distance, snap) {
-    const target = targetVector.get() + distance;
-    const {
-      index,
-      distance: targetSnapDistance
-    } = findTargetSnap(target);
-    const reachedBound = !loop && reachedAny(target);
-    if (!snap || reachedBound) return {
-      index,
-      distance
-    };
-    const diffToSnap = scrollSnaps[index] - targetSnapDistance;
-    const snapDistance = distance + shortcut(diffToSnap, 0);
-    return {
-      index,
-      distance: snapDistance
-    };
-  }
-  const self = {
-    byDistance,
-    byIndex,
-    shortcut
-  };
-  return self;
-}
-function ScrollTo(animation, indexCurrent, indexPrevious, scrollBody, scrollTarget, targetVector, eventHandler) {
-  function scrollTo(target) {
-    const distanceDiff = target.distance;
-    const indexDiff = target.index !== indexCurrent.get();
-    targetVector.add(distanceDiff);
-    if (distanceDiff) {
-      if (scrollBody.duration()) {
-        animation.start();
-      } else {
-        animation.update();
-        animation.render(1);
-        animation.update();
-      }
-    }
-    if (indexDiff) {
-      indexPrevious.set(indexCurrent.get());
-      indexCurrent.set(target.index);
-      eventHandler.emit("select");
-    }
-  }
-  function distance(n, snap) {
-    const target = scrollTarget.byDistance(n, snap);
-    scrollTo(target);
-  }
-  function index(n, direction) {
-    const targetIndex = indexCurrent.clone().set(n);
-    const target = scrollTarget.byIndex(targetIndex.get(), direction);
-    scrollTo(target);
-  }
-  const self = {
-    distance,
-    index
-  };
-  return self;
-}
-function SlideFocus(root, slides, slideRegistry, scrollTo, scrollBody, eventStore, eventHandler, watchFocus) {
-  const focusListenerOptions = {
-    passive: true,
-    capture: true
-  };
-  let lastTabPressTime = 0;
-  function init(emblaApi) {
-    if (!watchFocus) return;
-    function defaultCallback(index) {
-      const nowTime = (/* @__PURE__ */ new Date()).getTime();
-      const diffTime = nowTime - lastTabPressTime;
-      if (diffTime > 10) return;
-      eventHandler.emit("slideFocusStart");
-      root.scrollLeft = 0;
-      const group = slideRegistry.findIndex((group2) => group2.includes(index));
-      if (!isNumber(group)) return;
-      scrollBody.useDuration(0);
-      scrollTo.index(group, 0);
-      eventHandler.emit("slideFocus");
-    }
-    eventStore.add(document, "keydown", registerTabPress, false);
-    slides.forEach((slide, slideIndex) => {
-      eventStore.add(slide, "focus", (evt) => {
-        if (isBoolean(watchFocus) || watchFocus(emblaApi, evt)) {
-          defaultCallback(slideIndex);
-        }
-      }, focusListenerOptions);
-    });
-  }
-  function registerTabPress(event) {
-    if (event.code === "Tab") lastTabPressTime = (/* @__PURE__ */ new Date()).getTime();
-  }
-  const self = {
-    init
-  };
-  return self;
-}
-function Vector1D(initialValue) {
-  let value = initialValue;
-  function get() {
-    return value;
-  }
-  function set(n) {
-    value = normalizeInput(n);
-  }
-  function add(n) {
-    value += normalizeInput(n);
-  }
-  function subtract(n) {
-    value -= normalizeInput(n);
-  }
-  function normalizeInput(n) {
-    return isNumber(n) ? n : n.get();
-  }
-  const self = {
-    get,
-    set,
-    add,
-    subtract
-  };
-  return self;
-}
-function Translate(axis, container) {
-  const translate = axis.scroll === "x" ? x : y;
-  const containerStyle = container.style;
-  let previousTarget = null;
-  let disabled2 = false;
-  function x(n) {
-    return `translate3d(${n}px,0px,0px)`;
-  }
-  function y(n) {
-    return `translate3d(0px,${n}px,0px)`;
-  }
-  function to(target) {
-    if (disabled2) return;
-    const newTarget = roundToTwoDecimals(axis.direction(target));
-    if (newTarget === previousTarget) return;
-    containerStyle.transform = translate(newTarget);
-    previousTarget = newTarget;
-  }
-  function toggleActive(active) {
-    disabled2 = !active;
-  }
-  function clear() {
-    if (disabled2) return;
-    containerStyle.transform = "";
-    if (!container.getAttribute("style")) container.removeAttribute("style");
-  }
-  const self = {
-    clear,
-    to,
-    toggleActive
-  };
-  return self;
-}
-function SlideLooper(axis, viewSize, contentSize, slideSizes, slideSizesWithGaps, snaps, scrollSnaps, location, slides) {
-  const roundingSafety = 0.5;
-  const ascItems = arrayKeys(slideSizesWithGaps);
-  const descItems = arrayKeys(slideSizesWithGaps).reverse();
-  const loopPoints = startPoints().concat(endPoints());
-  function removeSlideSizes(indexes, from) {
-    return indexes.reduce((a, i) => {
-      return a - slideSizesWithGaps[i];
-    }, from);
-  }
-  function slidesInGap(indexes, gap) {
-    return indexes.reduce((a, i) => {
-      const remainingGap = removeSlideSizes(a, gap);
-      return remainingGap > 0 ? a.concat([i]) : a;
-    }, []);
-  }
-  function findSlideBounds(offset) {
-    return snaps.map((snap, index) => ({
-      start: snap - slideSizes[index] + roundingSafety + offset,
-      end: snap + viewSize - roundingSafety + offset
-    }));
-  }
-  function findLoopPoints(indexes, offset, isEndEdge) {
-    const slideBounds = findSlideBounds(offset);
-    return indexes.map((index) => {
-      const initial = isEndEdge ? 0 : -contentSize;
-      const altered = isEndEdge ? contentSize : 0;
-      const boundEdge = isEndEdge ? "end" : "start";
-      const loopPoint = slideBounds[index][boundEdge];
-      return {
-        index,
-        loopPoint,
-        slideLocation: Vector1D(-1),
-        translate: Translate(axis, slides[index]),
-        target: () => location.get() > loopPoint ? initial : altered
-      };
-    });
-  }
-  function startPoints() {
-    const gap = scrollSnaps[0];
-    const indexes = slidesInGap(descItems, gap);
-    return findLoopPoints(indexes, contentSize, false);
-  }
-  function endPoints() {
-    const gap = viewSize - scrollSnaps[0] - 1;
-    const indexes = slidesInGap(ascItems, gap);
-    return findLoopPoints(indexes, -contentSize, true);
-  }
-  function canLoop() {
-    return loopPoints.every(({
-      index
-    }) => {
-      const otherIndexes = ascItems.filter((i) => i !== index);
-      return removeSlideSizes(otherIndexes, viewSize) <= 0.1;
-    });
-  }
-  function loop() {
-    loopPoints.forEach((loopPoint) => {
-      const {
-        target,
-        translate,
-        slideLocation
-      } = loopPoint;
-      const shiftLocation = target();
-      if (shiftLocation === slideLocation.get()) return;
-      translate.to(shiftLocation);
-      slideLocation.set(shiftLocation);
-    });
-  }
-  function clear() {
-    loopPoints.forEach((loopPoint) => loopPoint.translate.clear());
-  }
-  const self = {
-    canLoop,
-    clear,
-    loop,
-    loopPoints
-  };
-  return self;
-}
-function SlidesHandler(container, eventHandler, watchSlides) {
-  let mutationObserver;
-  let destroyed = false;
-  function init(emblaApi) {
-    if (!watchSlides) return;
-    function defaultCallback(mutations) {
-      for (const mutation of mutations) {
-        if (mutation.type === "childList") {
-          emblaApi.reInit();
-          eventHandler.emit("slidesChanged");
-          break;
-        }
-      }
-    }
-    mutationObserver = new MutationObserver((mutations) => {
-      if (destroyed) return;
-      if (isBoolean(watchSlides) || watchSlides(emblaApi, mutations)) {
-        defaultCallback(mutations);
-      }
-    });
-    mutationObserver.observe(container, {
-      childList: true
-    });
-  }
-  function destroy() {
-    if (mutationObserver) mutationObserver.disconnect();
-    destroyed = true;
-  }
-  const self = {
-    init,
-    destroy
-  };
-  return self;
-}
-function SlidesInView(container, slides, eventHandler, threshold) {
-  const intersectionEntryMap = {};
-  let inViewCache = null;
-  let notInViewCache = null;
-  let intersectionObserver;
-  let destroyed = false;
-  function init() {
-    intersectionObserver = new IntersectionObserver((entries) => {
-      if (destroyed) return;
-      entries.forEach((entry) => {
-        const index = slides.indexOf(entry.target);
-        intersectionEntryMap[index] = entry;
-      });
-      inViewCache = null;
-      notInViewCache = null;
-      eventHandler.emit("slidesInView");
-    }, {
-      root: container.parentElement,
-      threshold
-    });
-    slides.forEach((slide) => intersectionObserver.observe(slide));
-  }
-  function destroy() {
-    if (intersectionObserver) intersectionObserver.disconnect();
-    destroyed = true;
-  }
-  function createInViewList(inView) {
-    return objectKeys(intersectionEntryMap).reduce((list, slideIndex) => {
-      const index = parseInt(slideIndex);
-      const {
-        isIntersecting
-      } = intersectionEntryMap[index];
-      const inViewMatch = inView && isIntersecting;
-      const notInViewMatch = !inView && !isIntersecting;
-      if (inViewMatch || notInViewMatch) list.push(index);
-      return list;
-    }, []);
-  }
-  function get(inView = true) {
-    if (inView && inViewCache) return inViewCache;
-    if (!inView && notInViewCache) return notInViewCache;
-    const slideIndexes = createInViewList(inView);
-    if (inView) inViewCache = slideIndexes;
-    if (!inView) notInViewCache = slideIndexes;
-    return slideIndexes;
-  }
-  const self = {
-    init,
-    destroy,
-    get
-  };
-  return self;
-}
-function SlideSizes(axis, containerRect, slideRects, slides, readEdgeGap, ownerWindow) {
-  const {
-    measureSize,
-    startEdge,
-    endEdge
-  } = axis;
-  const withEdgeGap = slideRects[0] && readEdgeGap;
-  const startGap = measureStartGap();
-  const endGap = measureEndGap();
-  const slideSizes = slideRects.map(measureSize);
-  const slideSizesWithGaps = measureWithGaps();
-  function measureStartGap() {
-    if (!withEdgeGap) return 0;
-    const slideRect = slideRects[0];
-    return mathAbs(containerRect[startEdge] - slideRect[startEdge]);
-  }
-  function measureEndGap() {
-    if (!withEdgeGap) return 0;
-    const style = ownerWindow.getComputedStyle(arrayLast(slides));
-    return parseFloat(style.getPropertyValue(`margin-${endEdge}`));
-  }
-  function measureWithGaps() {
-    return slideRects.map((rect, index, rects) => {
-      const isFirst = !index;
-      const isLast = arrayIsLastIndex(rects, index);
-      if (isFirst) return slideSizes[index] + startGap;
-      if (isLast) return slideSizes[index] + endGap;
-      return rects[index + 1][startEdge] - rect[startEdge];
-    }).map(mathAbs);
-  }
-  const self = {
-    slideSizes,
-    slideSizesWithGaps,
-    startGap,
-    endGap
-  };
-  return self;
-}
-function SlidesToScroll(axis, viewSize, slidesToScroll, loop, containerRect, slideRects, startGap, endGap, pixelTolerance) {
-  const {
-    startEdge,
-    endEdge,
-    direction
-  } = axis;
-  const groupByNumber = isNumber(slidesToScroll);
-  function byNumber(array, groupSize) {
-    return arrayKeys(array).filter((i) => i % groupSize === 0).map((i) => array.slice(i, i + groupSize));
-  }
-  function bySize(array) {
-    if (!array.length) return [];
-    return arrayKeys(array).reduce((groups, rectB, index) => {
-      const rectA = arrayLast(groups) || 0;
-      const isFirst = rectA === 0;
-      const isLast = rectB === arrayLastIndex(array);
-      const edgeA = containerRect[startEdge] - slideRects[rectA][startEdge];
-      const edgeB = containerRect[startEdge] - slideRects[rectB][endEdge];
-      const gapA = !loop && isFirst ? direction(startGap) : 0;
-      const gapB = !loop && isLast ? direction(endGap) : 0;
-      const chunkSize = mathAbs(edgeB - gapB - (edgeA + gapA));
-      if (index && chunkSize > viewSize + pixelTolerance) groups.push(rectB);
-      if (isLast) groups.push(array.length);
-      return groups;
-    }, []).map((currentSize, index, groups) => {
-      const previousSize = Math.max(groups[index - 1] || 0);
-      return array.slice(previousSize, currentSize);
-    });
-  }
-  function groupSlides(array) {
-    return groupByNumber ? byNumber(array, slidesToScroll) : bySize(array);
-  }
-  const self = {
-    groupSlides
-  };
-  return self;
-}
-function Engine(root, container, slides, ownerDocument, ownerWindow, options, eventHandler) {
-  const {
-    align,
-    axis: scrollAxis,
-    direction,
-    startIndex,
-    loop,
-    duration,
-    dragFree,
-    dragThreshold,
-    inViewThreshold,
-    slidesToScroll: groupSlides,
-    skipSnaps,
-    containScroll,
-    watchResize,
-    watchSlides,
-    watchDrag,
-    watchFocus
-  } = options;
-  const pixelTolerance = 2;
-  const nodeRects = NodeRects();
-  const containerRect = nodeRects.measure(container);
-  const slideRects = slides.map(nodeRects.measure);
-  const axis = Axis(scrollAxis, direction);
-  const viewSize = axis.measureSize(containerRect);
-  const percentOfView = PercentOfView(viewSize);
-  const alignment = Alignment(align, viewSize);
-  const containSnaps = !loop && !!containScroll;
-  const readEdgeGap = loop || !!containScroll;
-  const {
-    slideSizes,
-    slideSizesWithGaps,
-    startGap,
-    endGap
-  } = SlideSizes(axis, containerRect, slideRects, slides, readEdgeGap, ownerWindow);
-  const slidesToScroll = SlidesToScroll(axis, viewSize, groupSlides, loop, containerRect, slideRects, startGap, endGap, pixelTolerance);
-  const {
-    snaps,
-    snapsAligned
-  } = ScrollSnaps(axis, alignment, containerRect, slideRects, slidesToScroll);
-  const contentSize = -arrayLast(snaps) + arrayLast(slideSizesWithGaps);
-  const {
-    snapsContained,
-    scrollContainLimit
-  } = ScrollContain(viewSize, contentSize, snapsAligned, containScroll, pixelTolerance);
-  const scrollSnaps = containSnaps ? snapsContained : snapsAligned;
-  const {
-    limit
-  } = ScrollLimit(contentSize, scrollSnaps, loop);
-  const index = Counter(arrayLastIndex(scrollSnaps), startIndex, loop);
-  const indexPrevious = index.clone();
-  const slideIndexes = arrayKeys(slides);
-  const update = ({
-    dragHandler,
-    scrollBody: scrollBody2,
-    scrollBounds,
-    options: {
-      loop: loop2
-    }
-  }) => {
-    if (!loop2) scrollBounds.constrain(dragHandler.pointerDown());
-    scrollBody2.seek();
-  };
-  const render = ({
-    scrollBody: scrollBody2,
-    translate,
-    location: location2,
-    offsetLocation: offsetLocation2,
-    previousLocation: previousLocation2,
-    scrollLooper,
-    slideLooper,
-    dragHandler,
-    animation: animation2,
-    eventHandler: eventHandler2,
-    scrollBounds,
-    options: {
-      loop: loop2
-    }
-  }, alpha) => {
-    const shouldSettle = scrollBody2.settled();
-    const withinBounds = !scrollBounds.shouldConstrain();
-    const hasSettled = loop2 ? shouldSettle : shouldSettle && withinBounds;
-    const hasSettledAndIdle = hasSettled && !dragHandler.pointerDown();
-    if (hasSettledAndIdle) animation2.stop();
-    const interpolatedLocation = location2.get() * alpha + previousLocation2.get() * (1 - alpha);
-    offsetLocation2.set(interpolatedLocation);
-    if (loop2) {
-      scrollLooper.loop(scrollBody2.direction());
-      slideLooper.loop();
-    }
-    translate.to(offsetLocation2.get());
-    if (hasSettledAndIdle) eventHandler2.emit("settle");
-    if (!hasSettled) eventHandler2.emit("scroll");
-  };
-  const animation = Animations(ownerDocument, ownerWindow, () => update(engine), (alpha) => render(engine, alpha));
-  const friction = 0.68;
-  const startLocation = scrollSnaps[index.get()];
-  const location = Vector1D(startLocation);
-  const previousLocation = Vector1D(startLocation);
-  const offsetLocation = Vector1D(startLocation);
-  const target = Vector1D(startLocation);
-  const scrollBody = ScrollBody(location, offsetLocation, previousLocation, target, duration, friction);
-  const scrollTarget = ScrollTarget(loop, scrollSnaps, contentSize, limit, target);
-  const scrollTo = ScrollTo(animation, index, indexPrevious, scrollBody, scrollTarget, target, eventHandler);
-  const scrollProgress = ScrollProgress(limit);
-  const eventStore = EventStore();
-  const slidesInView = SlidesInView(container, slides, eventHandler, inViewThreshold);
-  const {
-    slideRegistry
-  } = SlideRegistry(containSnaps, containScroll, scrollSnaps, scrollContainLimit, slidesToScroll, slideIndexes);
-  const slideFocus = SlideFocus(root, slides, slideRegistry, scrollTo, scrollBody, eventStore, eventHandler, watchFocus);
-  const engine = {
-    ownerDocument,
-    ownerWindow,
-    eventHandler,
-    containerRect,
-    slideRects,
-    animation,
-    axis,
-    dragHandler: DragHandler(axis, root, ownerDocument, ownerWindow, target, DragTracker(axis, ownerWindow), location, animation, scrollTo, scrollBody, scrollTarget, index, eventHandler, percentOfView, dragFree, dragThreshold, skipSnaps, friction, watchDrag),
-    eventStore,
-    percentOfView,
-    index,
-    indexPrevious,
-    limit,
-    location,
-    offsetLocation,
-    previousLocation,
-    options,
-    resizeHandler: ResizeHandler(container, eventHandler, ownerWindow, slides, axis, watchResize, nodeRects),
-    scrollBody,
-    scrollBounds: ScrollBounds(limit, offsetLocation, target, scrollBody, percentOfView),
-    scrollLooper: ScrollLooper(contentSize, limit, offsetLocation, [location, offsetLocation, previousLocation, target]),
-    scrollProgress,
-    scrollSnapList: scrollSnaps.map(scrollProgress.get),
-    scrollSnaps,
-    scrollTarget,
-    scrollTo,
-    slideLooper: SlideLooper(axis, viewSize, contentSize, slideSizes, slideSizesWithGaps, snaps, scrollSnaps, offsetLocation, slides),
-    slideFocus,
-    slidesHandler: SlidesHandler(container, eventHandler, watchSlides),
-    slidesInView,
-    slideIndexes,
-    slideRegistry,
-    slidesToScroll,
-    target,
-    translate: Translate(axis, container)
-  };
-  return engine;
-}
-function EventHandler() {
-  let listeners = {};
-  let api;
-  function init(emblaApi) {
-    api = emblaApi;
-  }
-  function getListeners(evt) {
-    return listeners[evt] || [];
-  }
-  function emit(evt) {
-    getListeners(evt).forEach((e2) => e2(api, evt));
-    return self;
-  }
-  function on(evt, cb) {
-    listeners[evt] = getListeners(evt).concat([cb]);
-    return self;
-  }
-  function off(evt, cb) {
-    listeners[evt] = getListeners(evt).filter((e2) => e2 !== cb);
-    return self;
-  }
-  function clear() {
-    listeners = {};
-  }
-  const self = {
-    init,
-    emit,
-    off,
-    on,
-    clear
-  };
-  return self;
-}
-const defaultOptions = {
-  align: "center",
-  axis: "x",
-  container: null,
-  slides: null,
-  containScroll: "trimSnaps",
-  direction: "ltr",
-  slidesToScroll: 1,
-  inViewThreshold: 0,
-  breakpoints: {},
-  dragFree: false,
-  dragThreshold: 10,
-  loop: false,
-  skipSnaps: false,
-  duration: 25,
-  startIndex: 0,
-  active: true,
-  watchDrag: true,
-  watchResize: true,
-  watchSlides: true,
-  watchFocus: true
-};
-function OptionsHandler(ownerWindow) {
-  function mergeOptions(optionsA, optionsB) {
-    return objectsMergeDeep(optionsA, optionsB || {});
-  }
-  function optionsAtMedia(options) {
-    const optionsAtMedia2 = options.breakpoints || {};
-    const matchedMediaOptions = objectKeys(optionsAtMedia2).filter((media) => ownerWindow.matchMedia(media).matches).map((media) => optionsAtMedia2[media]).reduce((a, mediaOption) => mergeOptions(a, mediaOption), {});
-    return mergeOptions(options, matchedMediaOptions);
-  }
-  function optionsMediaQueries(optionsList) {
-    return optionsList.map((options) => objectKeys(options.breakpoints || {})).reduce((acc, mediaQueries) => acc.concat(mediaQueries), []).map(ownerWindow.matchMedia);
-  }
-  const self = {
-    mergeOptions,
-    optionsAtMedia,
-    optionsMediaQueries
-  };
-  return self;
-}
-function PluginsHandler(optionsHandler) {
-  let activePlugins = [];
-  function init(emblaApi, plugins) {
-    activePlugins = plugins.filter(({
-      options
-    }) => optionsHandler.optionsAtMedia(options).active !== false);
-    activePlugins.forEach((plugin) => plugin.init(emblaApi, optionsHandler));
-    return plugins.reduce((map, plugin) => Object.assign(map, {
-      [plugin.name]: plugin
-    }), {});
-  }
-  function destroy() {
-    activePlugins = activePlugins.filter((plugin) => plugin.destroy());
-  }
-  const self = {
-    init,
-    destroy
-  };
-  return self;
-}
-function EmblaCarousel(root, userOptions, userPlugins) {
-  const ownerDocument = root.ownerDocument;
-  const ownerWindow = ownerDocument.defaultView;
-  const optionsHandler = OptionsHandler(ownerWindow);
-  const pluginsHandler = PluginsHandler(optionsHandler);
-  const mediaHandlers = EventStore();
-  const eventHandler = EventHandler();
-  const {
-    mergeOptions,
-    optionsAtMedia,
-    optionsMediaQueries
-  } = optionsHandler;
-  const {
-    on,
-    off,
-    emit
-  } = eventHandler;
-  const reInit = reActivate;
-  let destroyed = false;
-  let engine;
-  let optionsBase = mergeOptions(defaultOptions, EmblaCarousel.globalOptions);
-  let options = mergeOptions(optionsBase);
-  let pluginList = [];
-  let pluginApis;
-  let container;
-  let slides;
-  function storeElements() {
-    const {
-      container: userContainer,
-      slides: userSlides
-    } = options;
-    const customContainer = isString(userContainer) ? root.querySelector(userContainer) : userContainer;
-    container = customContainer || root.children[0];
-    const customSlides = isString(userSlides) ? container.querySelectorAll(userSlides) : userSlides;
-    slides = [].slice.call(customSlides || container.children);
-  }
-  function createEngine(options2) {
-    const engine2 = Engine(root, container, slides, ownerDocument, ownerWindow, options2, eventHandler);
-    if (options2.loop && !engine2.slideLooper.canLoop()) {
-      const optionsWithoutLoop = Object.assign({}, options2, {
-        loop: false
-      });
-      return createEngine(optionsWithoutLoop);
-    }
-    return engine2;
-  }
-  function activate(withOptions, withPlugins) {
-    if (destroyed) return;
-    optionsBase = mergeOptions(optionsBase, withOptions);
-    options = optionsAtMedia(optionsBase);
-    pluginList = withPlugins || pluginList;
-    storeElements();
-    engine = createEngine(options);
-    optionsMediaQueries([optionsBase, ...pluginList.map(({
-      options: options2
-    }) => options2)]).forEach((query) => mediaHandlers.add(query, "change", reActivate));
-    if (!options.active) return;
-    engine.translate.to(engine.location.get());
-    engine.animation.init();
-    engine.slidesInView.init();
-    engine.slideFocus.init(self);
-    engine.eventHandler.init(self);
-    engine.resizeHandler.init(self);
-    engine.slidesHandler.init(self);
-    if (engine.options.loop) engine.slideLooper.loop();
-    if (container.offsetParent && slides.length) engine.dragHandler.init(self);
-    pluginApis = pluginsHandler.init(self, pluginList);
-  }
-  function reActivate(withOptions, withPlugins) {
-    const startIndex = selectedScrollSnap();
-    deActivate();
-    activate(mergeOptions({
-      startIndex
-    }, withOptions), withPlugins);
-    eventHandler.emit("reInit");
-  }
-  function deActivate() {
-    engine.dragHandler.destroy();
-    engine.eventStore.clear();
-    engine.translate.clear();
-    engine.slideLooper.clear();
-    engine.resizeHandler.destroy();
-    engine.slidesHandler.destroy();
-    engine.slidesInView.destroy();
-    engine.animation.destroy();
-    pluginsHandler.destroy();
-    mediaHandlers.clear();
-  }
-  function destroy() {
-    if (destroyed) return;
-    destroyed = true;
-    mediaHandlers.clear();
-    deActivate();
-    eventHandler.emit("destroy");
-    eventHandler.clear();
-  }
-  function scrollTo(index, jump, direction) {
-    if (!options.active || destroyed) return;
-    engine.scrollBody.useBaseFriction().useDuration(jump === true ? 0 : options.duration);
-    engine.scrollTo.index(index, direction || 0);
-  }
-  function scrollNext(jump) {
-    const next = engine.index.add(1).get();
-    scrollTo(next, jump, -1);
-  }
-  function scrollPrev(jump) {
-    const prev = engine.index.add(-1).get();
-    scrollTo(prev, jump, 1);
-  }
-  function canScrollNext() {
-    const next = engine.index.add(1).get();
-    return next !== selectedScrollSnap();
-  }
-  function canScrollPrev() {
-    const prev = engine.index.add(-1).get();
-    return prev !== selectedScrollSnap();
-  }
-  function scrollSnapList() {
-    return engine.scrollSnapList;
-  }
-  function scrollProgress() {
-    return engine.scrollProgress.get(engine.offsetLocation.get());
-  }
-  function selectedScrollSnap() {
-    return engine.index.get();
-  }
-  function previousScrollSnap() {
-    return engine.indexPrevious.get();
-  }
-  function slidesInView() {
-    return engine.slidesInView.get();
-  }
-  function slidesNotInView() {
-    return engine.slidesInView.get(false);
-  }
-  function plugins() {
-    return pluginApis;
-  }
-  function internalEngine() {
-    return engine;
-  }
-  function rootNode() {
-    return root;
-  }
-  function containerNode() {
-    return container;
-  }
-  function slideNodes() {
-    return slides;
-  }
-  const self = {
-    canScrollNext,
-    canScrollPrev,
-    containerNode,
-    internalEngine,
-    destroy,
-    off,
-    on,
-    emit,
-    plugins,
-    previousScrollSnap,
-    reInit,
-    rootNode,
-    scrollNext,
-    scrollPrev,
-    scrollProgress,
-    scrollSnapList,
-    scrollTo,
-    selectedScrollSnap,
-    slideNodes,
-    slidesInView,
-    slidesNotInView
-  };
-  activate(userOptions, userPlugins);
-  setTimeout(() => eventHandler.emit("init"), 0);
-  return self;
-}
-EmblaCarousel.globalOptions = void 0;
-function useEmblaCarousel(options = {}, plugins = []) {
-  const storedOptions = useRef(options);
-  const storedPlugins = useRef(plugins);
-  const [emblaApi, setEmblaApi] = useState();
-  const [viewport, setViewport] = useState();
-  const reInit = useCallback(() => {
-    if (emblaApi) emblaApi.reInit(storedOptions.current, storedPlugins.current);
-  }, [emblaApi]);
-  useEffect(() => {
-    if (areOptionsEqual(storedOptions.current, options)) return;
-    storedOptions.current = options;
-    reInit();
-  }, [options, reInit]);
-  useEffect(() => {
-    if (arePluginsEqual(storedPlugins.current, plugins)) return;
-    storedPlugins.current = plugins;
-    reInit();
-  }, [plugins, reInit]);
-  useEffect(() => {
-    if (canUseDOM() && viewport) {
-      EmblaCarousel.globalOptions = useEmblaCarousel.globalOptions;
-      const newEmblaApi = EmblaCarousel(viewport, storedOptions.current, storedPlugins.current);
-      setEmblaApi(newEmblaApi);
-      return () => newEmblaApi.destroy();
-    } else {
-      setEmblaApi(void 0);
-    }
-  }, [viewport, setEmblaApi]);
-  return [setViewport, emblaApi];
-}
-useEmblaCarousel.globalOptions = void 0;
-const [CarouselProvider, useCarouselContext] = createSafeContext(
-  "Carousel component was not found in tree"
-);
-var classes = { "root": "m_17884d0f", "viewport": "m_a2dae653", "container": "m_fcd81474", "controls": "m_39bc3463", "control": "m_64f58e10", "indicators": "m_71ea3ab1", "indicator": "m_eae68602", "slide": "m_d98df724" };
-const CarouselSlide = factory((props, ref) => {
-  const { classNames, className, style, styles: styles2, vars, mod, ...others } = useProps(
-    "CarouselSlide",
-    null,
-    props
-  );
-  const ctx = useCarouselContext();
-  return /* @__PURE__ */ jsx(
-    Box,
-    {
-      ref,
-      mod: [{ orientation: ctx.orientation }, mod],
-      ...ctx.getStyles("slide", { className, style, classNames, styles: styles2 }),
-      ...others
-    }
-  );
-});
-CarouselSlide.classes = classes;
-CarouselSlide.displayName = "@mantine/carousel/CarouselSlide";
-function CarouselVariables({ slideGap, slideSize, selector }) {
-  const theme = useMantineTheme();
-  const baseStyles = filterProps({
-    "--carousel-slide-gap": getSpacing(getBaseValue(slideGap)),
-    "--carousel-slide-size": rem(getBaseValue(slideSize))
-  });
-  const queries = keys(theme.breakpoints).reduce(
-    (acc, breakpoint) => {
-      if (!acc[breakpoint]) {
-        acc[breakpoint] = {};
-      }
-      if (typeof slideGap === "object" && slideGap[breakpoint] !== void 0) {
-        acc[breakpoint]["--carousel-slide-gap"] = getSpacing(slideGap[breakpoint]);
-      }
-      if (typeof slideSize === "object" && slideSize[breakpoint] !== void 0) {
-        acc[breakpoint]["--carousel-slide-size"] = getSpacing(slideSize[breakpoint]);
-      }
-      return acc;
-    },
-    {}
-  );
-  const sortedBreakpoints = getSortedBreakpoints(keys(queries), theme.breakpoints).filter(
-    (breakpoint) => keys(queries[breakpoint.value]).length > 0
-  );
-  const media = sortedBreakpoints.map((breakpoint) => ({
-    query: `(min-width: ${theme.breakpoints[breakpoint.value]})`,
-    styles: queries[breakpoint.value]
-  }));
-  return /* @__PURE__ */ jsx(InlineStyles, { styles: baseStyles, media, selector });
-}
-function getBreakpoints(values) {
-  if (typeof values === "object" && values !== null) {
-    return keys(values);
-  }
-  return [];
-}
-function sortBreakpoints(breakpoints) {
-  return breakpoints.sort((a, b) => px(a) - px(b));
-}
-function getUniqueBreakpoints({ slideGap, slideSize }) {
-  const breakpoints = Array.from(
-    /* @__PURE__ */ new Set([...getBreakpoints(slideGap), ...getBreakpoints(slideSize)])
-  );
-  return sortBreakpoints(breakpoints);
-}
-function CarouselContainerVariables({
-  slideGap,
-  slideSize,
-  selector
-}) {
-  const baseStyles = filterProps({
-    "--carousel-slide-gap": getSpacing(getBaseValue(slideGap)),
-    "--carousel-slide-size": rem(getBaseValue(slideSize))
-  });
-  const queries = getUniqueBreakpoints({ slideGap, slideSize }).reduce((acc, breakpoint) => {
-    if (!acc[breakpoint]) {
-      acc[breakpoint] = {};
-    }
-    if (typeof slideGap === "object" && slideGap[breakpoint] !== void 0) {
-      acc[breakpoint]["--carousel-slide-gap"] = getSpacing(slideGap[breakpoint]);
-    }
-    if (typeof slideSize === "object" && slideSize[breakpoint] !== void 0) {
-      acc[breakpoint]["--carousel-slide-size"] = getSpacing(slideSize[breakpoint]);
-    }
-    return acc;
-  }, {});
-  const media = Object.keys(queries).map((breakpoint) => ({
-    query: `carousel (min-width: ${breakpoint})`,
-    styles: queries[breakpoint]
-  }));
-  return /* @__PURE__ */ jsx(InlineStyles, { styles: baseStyles, container: media, selector });
-}
-function getChevronRotation({ dir, orientation, direction }) {
-  if (direction === "previous") {
-    return orientation === "horizontal" ? 90 * (dir === "ltr" ? 1 : -1) : -180;
-  }
-  return orientation === "horizontal" ? 90 * (dir === "ltr" ? -1 : 1) : 0;
-}
-const defaultProps = {
-  controlSize: 26,
-  controlsOffset: "sm",
-  slideSize: "100%",
-  slideGap: 0,
-  orientation: "horizontal",
-  includeGapInSize: true,
-  initialSlide: 0,
-  withControls: true,
-  withIndicators: false,
-  withKeyboardEvents: true,
-  type: "media"
-};
-const defaultEmblaOptions = {
-  align: "center",
-  loop: false,
-  slidesToScroll: 1,
-  dragFree: false,
-  inViewThreshold: 0,
-  skipSnaps: false,
-  containScroll: "trimSnaps"
-};
-const varsResolver = createVarsResolver(
-  (_, { height, controlSize, controlsOffset }) => ({
-    root: {
-      "--carousel-height": rem(height),
-      "--carousel-control-size": rem(controlSize),
-      "--carousel-controls-offset": getSpacing(controlsOffset)
-    }
-  })
-);
-const Carousel = factory((_props, ref) => {
-  const props = useProps("Carousel", defaultProps, _props);
-  const {
-    classNames,
-    className,
-    style,
-    styles: styles2,
-    unstyled,
-    vars,
-    children,
-    getEmblaApi,
-    onNextSlide,
-    onPreviousSlide,
-    onSlideChange,
-    nextControlProps,
-    previousControlProps,
-    controlSize,
-    controlsOffset,
-    slideSize,
-    slideGap,
-    orientation,
-    height,
-    includeGapInSize,
-    draggable,
-    initialSlide,
-    withControls,
-    withIndicators,
-    plugins,
-    nextControlIcon,
-    previousControlIcon,
-    withKeyboardEvents,
-    mod,
-    type,
-    emblaOptions,
-    attributes,
-    ...others
-  } = props;
-  const getStyles = useStyles({
-    name: "Carousel",
-    classes,
-    props,
-    className,
-    style,
-    classNames,
-    styles: styles2,
-    unstyled,
-    attributes,
-    vars,
-    varsResolver
-  });
-  const responsiveClassName = useRandomClassName();
-  const { dir } = useDirection();
-  const [emblaRefElement, embla] = useEmblaCarousel(
-    {
-      axis: orientation === "horizontal" ? "x" : "y",
-      direction: orientation === "horizontal" ? dir : void 0,
-      startIndex: initialSlide,
-      ...defaultEmblaOptions,
-      ...emblaOptions
-    },
-    plugins
-  );
-  const [selected, setSelected] = useState(0);
-  const [slidesCount, setSlidesCount] = useState(0);
-  const handleScroll = useCallback((index) => embla && embla.scrollTo(index), [embla]);
-  const handleSelect = useCallback(() => {
-    if (!embla) {
-      return;
-    }
-    const slide = embla.selectedScrollSnap();
-    setSelected(slide);
-    slide !== selected && (onSlideChange == null ? void 0 : onSlideChange(slide));
-  }, [embla, setSelected, onSlideChange, selected]);
-  const handlePrevious = useCallback(() => {
-    embla == null ? void 0 : embla.scrollPrev();
-    onPreviousSlide == null ? void 0 : onPreviousSlide();
-  }, [embla]);
-  const handleNext = useCallback(() => {
-    embla == null ? void 0 : embla.scrollNext();
-    onNextSlide == null ? void 0 : onNextSlide();
-  }, [embla]);
-  const handleKeydown = useCallback(
-    (event) => {
-      if (withKeyboardEvents) {
-        if (event.key === "ArrowRight") {
-          event.preventDefault();
-          handleNext();
-        }
-        if (event.key === "ArrowLeft") {
-          event.preventDefault();
-          handlePrevious();
-        }
-      }
-    },
-    [embla]
-  );
-  useEffect(() => {
-    if (embla) {
-      getEmblaApi == null ? void 0 : getEmblaApi(embla);
-      handleSelect();
-      setSlidesCount(embla.scrollSnapList().length);
-      embla.on("select", handleSelect);
-      return () => {
-        embla.off("select", handleSelect);
-      };
-    }
-    return void 0;
-  }, [embla, emblaOptions == null ? void 0 : emblaOptions.slidesToScroll, handleSelect]);
-  useEffect(() => {
-    if (embla) {
-      embla.reInit();
-      setSlidesCount(embla.scrollSnapList().length);
-      setSelected(
-        (currentSelected) => clamp$1(currentSelected, 0, Children.toArray(children).length - 1)
-      );
-    }
-  }, [Children.toArray(children).length, emblaOptions == null ? void 0 : emblaOptions.slidesToScroll]);
-  const canScrollPrev = (embla == null ? void 0 : embla.canScrollPrev()) || false;
-  const canScrollNext = (embla == null ? void 0 : embla.canScrollNext()) || false;
-  const indicators = Array(slidesCount).fill(0).map((_, index) => /* @__PURE__ */ createElement(
-    UnstyledButton,
-    {
-      ...getStyles("indicator"),
-      key: index,
-      "data-active": index === selected || void 0,
-      "aria-hidden": true,
-      tabIndex: -1,
-      onClick: () => handleScroll(index),
-      "data-orientation": orientation,
-      onMouseDown: (event) => event.preventDefault()
-    }
-  ));
-  return /* @__PURE__ */ jsxs(CarouselProvider, { value: { getStyles, orientation }, children: [
-    type === "container" ? /* @__PURE__ */ jsx(CarouselContainerVariables, { ...props, selector: `.${responsiveClassName}` }) : /* @__PURE__ */ jsx(CarouselVariables, { ...props, selector: `.${responsiveClassName}` }),
-    /* @__PURE__ */ jsxs(
-      Box,
-      {
-        ref,
-        ...getStyles("root", { className: "responsiveClassName" }),
-        ...others,
-        mod: [{ orientation, "include-gap-in-size": includeGapInSize }, mod],
-        onKeyDownCapture: handleKeydown,
-        children: [
-          /* @__PURE__ */ jsx("div", { ...getStyles("viewport"), ref: emblaRefElement, "data-type": type, children: /* @__PURE__ */ jsx(
-            "div",
-            {
-              ...getStyles("container", { className: responsiveClassName }),
-              "data-orientation": orientation,
-              children
-            }
-          ) }),
-          withIndicators && /* @__PURE__ */ jsx("div", { ...getStyles("indicators"), "data-orientation": orientation, children: indicators }),
-          withControls && /* @__PURE__ */ jsxs("div", { ...getStyles("controls"), "data-orientation": orientation, children: [
-            /* @__PURE__ */ jsx(
-              UnstyledButton,
-              {
-                ...previousControlProps,
-                ...getStyles("control", {
-                  className: previousControlProps == null ? void 0 : previousControlProps.className,
-                  style: previousControlProps == null ? void 0 : previousControlProps.style
-                }),
-                onClick: (event) => {
-                  var _a;
-                  handlePrevious();
-                  (_a = previousControlProps == null ? void 0 : previousControlProps.onClick) == null ? void 0 : _a.call(previousControlProps, event);
-                },
-                "data-inactive": !canScrollPrev || void 0,
-                "data-type": "previous",
-                tabIndex: canScrollPrev ? 0 : -1,
-                children: typeof previousControlIcon !== "undefined" ? previousControlIcon : /* @__PURE__ */ jsx(
-                  AccordionChevron,
-                  {
-                    style: {
-                      transform: `rotate(${getChevronRotation({
-                        dir,
-                        orientation,
-                        direction: "previous"
-                      })}deg)`
-                    }
-                  }
-                )
-              }
-            ),
-            /* @__PURE__ */ jsx(
-              UnstyledButton,
-              {
-                ...getStyles("control", {
-                  className: nextControlProps == null ? void 0 : nextControlProps.className,
-                  style: nextControlProps == null ? void 0 : nextControlProps.style
-                }),
-                ...nextControlProps,
-                onClick: (event) => {
-                  var _a;
-                  handleNext();
-                  (_a = nextControlProps == null ? void 0 : nextControlProps.onClick) == null ? void 0 : _a.call(nextControlProps, event);
-                },
-                "data-inactive": !canScrollNext || void 0,
-                "data-type": "next",
-                tabIndex: canScrollNext ? 0 : -1,
-                children: typeof nextControlIcon !== "undefined" ? nextControlIcon : /* @__PURE__ */ jsx(
-                  AccordionChevron,
-                  {
-                    style: {
-                      transform: `rotate(${getChevronRotation({
-                        dir,
-                        orientation,
-                        direction: "next"
-                      })}deg)`
-                    }
-                  }
-                )
-              }
-            )
-          ] })
-        ]
-      }
-    )
-  ] });
-});
-Carousel.classes = classes;
-Carousel.displayName = "@mantine/carousel/Carousel";
-Carousel.Slide = CarouselSlide;
 function CoverSection({
   opened,
   videoId,
@@ -7855,7 +5710,7 @@ function CoverSection({
   const selectedUrl = useMemo(() => {
     var _a2, _b2;
     if (selectedPosterUrl) return selectedPosterUrl;
-    return ((_a2 = previews.find((p2) => p2.id === effectiveSelected)) == null ? void 0 : _a2.url) ?? ((_b2 = status == null ? void 0 : status.cover) == null ? void 0 : _b2.url) ?? null;
+    return ((_a2 = previews.find((p) => p.id === effectiveSelected)) == null ? void 0 : _a2.url) ?? ((_b2 = status == null ? void 0 : status.cover) == null ? void 0 : _b2.url) ?? null;
   }, [selectedPosterUrl, previews, effectiveSelected, (_b = status == null ? void 0 : status.cover) == null ? void 0 : _b.url]);
   useEffect(() => {
     if (!opened || !videoId) return;
@@ -7967,7 +5822,7 @@ function CoverSection({
                 },
                 role: "button",
                 tabIndex: 0,
-                onKeyDown: (e2) => e2.key === "Enter" && !isError && (() => {
+                onKeyDown: (e) => e.key === "Enter" && !isError && (() => {
                   setSelectedPreviewId(preview.id);
                   onSelectedPosterChange == null ? void 0 : onSelectedPosterChange(preview.url);
                 })(),
@@ -8376,10 +6231,10 @@ function ManualSubtitlesPanel({
 function DraftRow({ draft, onChange, onUpload, onRemove }) {
   const { t } = useTranslation();
   const inputRef = useRef(null);
-  const handleFileChange = (e2) => {
+  const handleFileChange = (e) => {
     var _a;
-    const file = (_a = e2.target.files) == null ? void 0 : _a[0];
-    e2.target.value = "";
+    const file = (_a = e.target.files) == null ? void 0 : _a[0];
+    e.target.value = "";
     if (!file) return;
     onUpload(file);
   };