@fdls/file-viewer 0.2.0

package/dist/index.js

@@ -0,0 +1,3351 @@
+import "./style.css";
+import { createContext, lazy, useState, useRef, useEffect, useCallback, useMemo, useId, useLayoutEffect, forwardRef, isValidElement, Suspense, useContext, cloneElement } from 'react';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { createPortal } from 'react-dom';
+import { Document, Page, pdfjs } from 'react-pdf';
+import { TransformWrapper, TransformComponent } from 'react-zoom-pan-pinch';
+import { useReactToPrint } from 'react-to-print';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+function assignRef(ref, value) {
+  if (typeof ref === "function") {
+    ref(value);
+    return;
+  }
+  if (ref && typeof ref === "object") {
+    ref.current = value;
+  }
+}
+function mergeRefs(...refs) {
+  return (value) => {
+    refs.forEach((ref) => assignRef(ref, value));
+  };
+}
+function renderAsChild(asChild, child, props) {
+  if (!isValidElement(child)) {
+    return child;
+  }
+  const element = child;
+  const mergedClassName = [props.className, element.props.className].filter(Boolean).join(" ");
+  const mergedStyle = {
+    ...props.style,
+    ...element.props.style
+  };
+  const propsOnClick = props.onClick;
+  const propsRef = props.ref;
+  return cloneElement(element, {
+    ...props,
+    ...element.props,
+    className: mergedClassName || void 0,
+    style: Object.keys(mergedStyle).length > 0 ? mergedStyle : void 0,
+    ref: mergeRefs(propsRef, element.props.ref),
+    onClick: (event) => {
+      propsOnClick?.(event);
+      element.props.onClick?.(event);
+    }
+  });
+}
+var init_as_child = __esm({
+  "src/features/file-viewer/primitives/as-child.ts"() {
+  }
+});
+function IconBase({ children, ...props }) {
+  return /* @__PURE__ */ jsx("svg", { ...ICON_DEFAULTS, ...props, children });
+}
+var ICON_DEFAULTS;
+var init_icon = __esm({
+  "src/features/file-viewer/components/icons/icon.tsx"() {
+    ICON_DEFAULTS = {
+      xmlns: "http://www.w3.org/2000/svg",
+      width: 24,
+      height: 24,
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: 2,
+      strokeLinecap: "round",
+      strokeLinejoin: "round"
+    };
+  }
+});
+function X(props) {
+  return /* @__PURE__ */ jsxs(IconBase, { ...props, children: [
+    /* @__PURE__ */ jsx("path", { d: "M18 6 6 18" }),
+    /* @__PURE__ */ jsx("path", { d: "m6 6 12 12" })
+  ] });
+}
+var init_X = __esm({
+  "src/features/file-viewer/components/icons/X.tsx"() {
+    init_icon();
+  }
+});
+function Download(props) {
+  return /* @__PURE__ */ jsxs(IconBase, { ...props, children: [
+    /* @__PURE__ */ jsx("path", { d: "M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" }),
+    /* @__PURE__ */ jsx("polyline", { points: "7 10 12 15 17 10" }),
+    /* @__PURE__ */ jsx("line", { x1: "12", x2: "12", y1: "15", y2: "3" })
+  ] });
+}
+var init_Download = __esm({
+  "src/features/file-viewer/components/icons/Download.tsx"() {
+    init_icon();
+  }
+});
+function Printer(props) {
+  return /* @__PURE__ */ jsxs(IconBase, { ...props, children: [
+    /* @__PURE__ */ jsx("path", { d: "M6 18H4a2 2 0 0 1-2-2v-5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2" }),
+    /* @__PURE__ */ jsx("path", { d: "M6 9V3a1 1 0 0 1 1-1h10a1 1 0 0 1 1 1v6" }),
+    /* @__PURE__ */ jsx("rect", { x: "6", y: "14", width: "12", height: "8", rx: "1" })
+  ] });
+}
+var init_Printer = __esm({
+  "src/features/file-viewer/components/icons/Printer.tsx"() {
+    init_icon();
+  }
+});
+function Maximize2(props) {
+  return /* @__PURE__ */ jsxs(IconBase, { ...props, children: [
+    /* @__PURE__ */ jsx("polyline", { points: "15 3 21 3 21 9" }),
+    /* @__PURE__ */ jsx("polyline", { points: "9 21 3 21 3 15" }),
+    /* @__PURE__ */ jsx("line", { x1: "21", x2: "14", y1: "3", y2: "10" }),
+    /* @__PURE__ */ jsx("line", { x1: "3", x2: "10", y1: "21", y2: "14" })
+  ] });
+}
+var init_Maximize2 = __esm({
+  "src/features/file-viewer/components/icons/Maximize2.tsx"() {
+    init_icon();
+  }
+});
+function LoaderCircle(props) {
+  return /* @__PURE__ */ jsx(IconBase, { ...props, children: /* @__PURE__ */ jsx("path", { d: "M21 12a9 9 0 1 1-6.219-8.56" }) });
+}
+var init_LoaderCircle = __esm({
+  "src/features/file-viewer/components/icons/LoaderCircle.tsx"() {
+    init_icon();
+  }
+});
+function ChevronLeft(props) {
+  return /* @__PURE__ */ jsx(IconBase, { ...props, children: /* @__PURE__ */ jsx("path", { d: "m15 18-6-6 6-6" }) });
+}
+var init_ChevronLeft = __esm({
+  "src/features/file-viewer/components/icons/ChevronLeft.tsx"() {
+    init_icon();
+  }
+});
+function ChevronRight(props) {
+  return /* @__PURE__ */ jsx(IconBase, { ...props, children: /* @__PURE__ */ jsx("path", { d: "m9 18 6-6-6-6" }) });
+}
+var init_ChevronRight = __esm({
+  "src/features/file-viewer/components/icons/ChevronRight.tsx"() {
+    init_icon();
+  }
+});
+function ZoomIn(props) {
+  return /* @__PURE__ */ jsxs(IconBase, { ...props, children: [
+    /* @__PURE__ */ jsx("circle", { cx: "11", cy: "11", r: "8" }),
+    /* @__PURE__ */ jsx("line", { x1: "21", x2: "16.65", y1: "21", y2: "16.65" }),
+    /* @__PURE__ */ jsx("line", { x1: "11", x2: "11", y1: "8", y2: "14" }),
+    /* @__PURE__ */ jsx("line", { x1: "8", x2: "14", y1: "11", y2: "11" })
+  ] });
+}
+var init_ZoomIn = __esm({
+  "src/features/file-viewer/components/icons/ZoomIn.tsx"() {
+    init_icon();
+  }
+});
+function ZoomOut(props) {
+  return /* @__PURE__ */ jsxs(IconBase, { ...props, children: [
+    /* @__PURE__ */ jsx("circle", { cx: "11", cy: "11", r: "8" }),
+    /* @__PURE__ */ jsx("line", { x1: "21", x2: "16.65", y1: "21", y2: "16.65" }),
+    /* @__PURE__ */ jsx("line", { x1: "8", x2: "14", y1: "11", y2: "11" })
+  ] });
+}
+var init_ZoomOut = __esm({
+  "src/features/file-viewer/components/icons/ZoomOut.tsx"() {
+    init_icon();
+  }
+});
+function Scan(props) {
+  return /* @__PURE__ */ jsxs(IconBase, { ...props, children: [
+    /* @__PURE__ */ jsx("path", { d: "M3 7V5a2 2 0 0 1 2-2h2" }),
+    /* @__PURE__ */ jsx("path", { d: "M17 3h2a2 2 0 0 1 2 2v2" }),
+    /* @__PURE__ */ jsx("path", { d: "M21 17v2a2 2 0 0 1-2 2h-2" }),
+    /* @__PURE__ */ jsx("path", { d: "M7 21H5a2 2 0 0 1-2-2v-2" })
+  ] });
+}
+var init_Scan = __esm({
+  "src/features/file-viewer/components/icons/Scan.tsx"() {
+    init_icon();
+  }
+});
+
+// src/features/file-viewer/components/icons/index.ts
+var init_icons = __esm({
+  "src/features/file-viewer/components/icons/index.ts"() {
+    init_X();
+    init_Download();
+    init_Printer();
+    init_Maximize2();
+    init_LoaderCircle();
+    init_ChevronLeft();
+    init_ChevronRight();
+    init_ZoomIn();
+    init_ZoomOut();
+    init_Scan();
+  }
+});
+
+// src/features/file-viewer/utils/deep-partial.ts
+function deepMergePartial(base, patch) {
+  if (!patch) {
+    return { ...base };
+  }
+  const result = { ...base };
+  const patchRecord = patch;
+  const resultRecord = result;
+  const baseRecord = base;
+  for (const key of Object.keys(patchRecord)) {
+    const patchValue = patchRecord[key];
+    if (patchValue === void 0) {
+      continue;
+    }
+    const baseValue = baseRecord[key];
+    if (typeof patchValue === "object" && patchValue !== null && !Array.isArray(patchValue) && typeof baseValue === "object" && baseValue !== null && !Array.isArray(baseValue)) {
+      resultRecord[key] = deepMergePartial(
+        baseValue,
+        patchValue
+      );
+      continue;
+    }
+    resultRecord[key] = patchValue;
+  }
+  return result;
+}
+var init_deep_partial = __esm({
+  "src/features/file-viewer/utils/deep-partial.ts"() {
+  }
+});
+
+// src/features/file-viewer/utils/merge-slot-props.ts
+function mergeClassNames(...classNames) {
+  return classNames.filter(Boolean).join(" ");
+}
+function mergeStyles(...styles) {
+  return Object.assign({}, ...styles.filter(Boolean));
+}
+function mergeSlotClassNames(...layers) {
+  const result = {};
+  for (const layer of layers) {
+    if (!layer) continue;
+    for (const key of Object.keys(layer)) {
+      const value = layer[key];
+      if (value !== void 0) {
+        result[key] = mergeClassNames(result[key], value);
+      }
+    }
+  }
+  return result;
+}
+function mergeSlotStyles(...layers) {
+  const result = {};
+  for (const layer of layers) {
+    if (!layer) continue;
+    for (const key of Object.keys(layer)) {
+      const value = layer[key];
+      if (value !== void 0) {
+        result[key] = mergeStyles(result[key], value);
+      }
+    }
+  }
+  return result;
+}
+var init_merge_slot_props = __esm({
+  "src/features/file-viewer/utils/merge-slot-props.ts"() {
+  }
+});
+
+// src/features/file-viewer/config.ts
+function mergePdfViewerLayer(current, partial) {
+  if (!partial) {
+    return current;
+  }
+  return {
+    ...current,
+    ...partial,
+    classNames: mergeSlotClassNames(
+      current?.classNames,
+      partial.classNames
+    ),
+    styles: mergeSlotStyles(current?.styles, partial.styles)
+  };
+}
+function mergeFileViewerDefaults(current, partial) {
+  return {
+    ...current,
+    ...partial,
+    dialogClassNames: mergeSlotClassNames(
+      current?.dialogClassNames,
+      partial.dialogClassNames
+    ),
+    dialogStyles: mergeSlotStyles(current?.dialogStyles, partial.dialogStyles),
+    classNames: mergeSlotClassNames(current?.classNames, partial.classNames),
+    styles: mergeSlotStyles(current?.styles, partial.styles),
+    pdfViewerProps: mergePdfViewerLayer(current?.pdfViewerProps, partial.pdfViewerProps)
+  };
+}
+function mergeImageViewerDefaults(current, partial) {
+  return {
+    ...current,
+    ...partial,
+    classNames: mergeSlotClassNames(
+      current?.classNames,
+      partial.classNames
+    ),
+    styles: mergeSlotStyles(current?.styles, partial.styles)
+  };
+}
+function mergeToolbarDefaults(current, partial) {
+  return {
+    ...current,
+    ...partial,
+    classNames: mergeSlotClassNames(current?.classNames, partial.classNames),
+    styles: mergeSlotStyles(current?.styles, partial.styles)
+  };
+}
+function mergeTooltipDefaults(current, partial) {
+  return {
+    ...current,
+    ...partial,
+    classNames: mergeSlotClassNames(current?.classNames, partial.classNames),
+    styles: mergeSlotStyles(current?.styles, partial.styles)
+  };
+}
+function mergeTranslationDefaults(current, partial) {
+  const next = {
+    ...current
+  };
+  for (const language of Object.keys(partial)) {
+    const patch = partial[language];
+    if (!patch) {
+      continue;
+    }
+    next[language] = deepMergePartial(
+      next[language] ?? {},
+      patch
+    );
+  }
+  return next;
+}
+function setFileViewerDefaults(partial) {
+  const next = { ...globalDefaults };
+  if (partial.language !== void 0) {
+    next.language = partial.language;
+  }
+  if (partial.fileViewer) {
+    next.fileViewer = mergeFileViewerDefaults(
+      next.fileViewer,
+      partial.fileViewer
+    );
+  }
+  if (partial.pdfViewer) {
+    next.pdfViewer = mergePdfViewerLayer(
+      next.pdfViewer,
+      partial.pdfViewer
+    );
+  }
+  if (partial.imageViewer) {
+    next.imageViewer = mergeImageViewerDefaults(
+      next.imageViewer,
+      partial.imageViewer
+    );
+  }
+  if (partial.toolbar) {
+    next.toolbar = mergeToolbarDefaults(
+      next.toolbar,
+      partial.toolbar
+    );
+  }
+  if (partial.tooltip) {
+    next.tooltip = mergeTooltipDefaults(
+      next.tooltip,
+      partial.tooltip
+    );
+  }
+  if (partial.autoHide) {
+    next.autoHide = { ...next.autoHide, ...partial.autoHide };
+  }
+  if (partial.translations) {
+    next.translations = mergeTranslationDefaults(
+      next.translations,
+      partial.translations
+    );
+  }
+  globalDefaults = next;
+}
+function getFileViewerDefaults() {
+  return globalDefaults;
+}
+function resetFileViewerDefaults() {
+  globalDefaults = {};
+}
+function resolvePdfViewerProps(instance = {}) {
+  const defaults = getFileViewerDefaults();
+  const merged = mergePdfViewerLayer(
+    mergePdfViewerLayer(defaults.pdfViewer, defaults.fileViewer?.pdfViewerProps),
+    instance
+  ) ?? {};
+  const legacyClassNames = {
+    ...instance.className || merged.className ? { root: instance.className ?? merged.className } : {},
+    ...instance.pageClassName || merged.pageClassName ? { page: instance.pageClassName ?? merged.pageClassName } : {},
+    ...instance.paginationClassName || merged.paginationClassName ? {
+      pagination: instance.paginationClassName ?? merged.paginationClassName
+    } : {}
+  };
+  return {
+    ...merged,
+    classNames: mergeSlotClassNames(
+      merged.classNames,
+      legacyClassNames
+    )
+  };
+}
+function resolveImageViewerProps(instance = {}) {
+  const defaults = getFileViewerDefaults();
+  const merged = mergeImageViewerDefaults(defaults.imageViewer, instance) ?? {};
+  return merged;
+}
+var globalDefaults;
+var init_config = __esm({
+  "src/features/file-viewer/config.ts"() {
+    init_deep_partial();
+    init_merge_slot_props();
+    globalDefaults = {};
+  }
+});
+
+// src/features/file-viewer/primitives/compute-tooltip-placement.ts
+function resolveSide({
+  preferredSide,
+  triggerRect,
+  contentHeight,
+  sideOffset,
+  padding,
+  viewportHeight
+}) {
+  const spaceAbove = triggerRect.top - padding;
+  const spaceBelow = viewportHeight - triggerRect.bottom - padding;
+  const needed = contentHeight + sideOffset;
+  if (preferredSide === "top") {
+    if (spaceAbove >= needed) return "top";
+    if (spaceBelow >= needed) return "bottom";
+    return spaceBelow > spaceAbove ? "bottom" : "top";
+  }
+  if (spaceBelow >= needed) return "bottom";
+  if (spaceAbove >= needed) return "top";
+  return spaceAbove > spaceBelow ? "top" : "bottom";
+}
+function computeTooltipPlacement(input) {
+  const padding = input.padding ?? 8;
+  const viewportWidth = input.viewportWidth ?? window.innerWidth;
+  const viewportHeight = input.viewportHeight ?? window.innerHeight;
+  const side = resolveSide({
+    ...input,
+    padding,
+    viewportHeight});
+  const top = side === "top" ? input.triggerRect.top - input.sideOffset - input.contentHeight : input.triggerRect.bottom + input.sideOffset;
+  let left = input.triggerRect.left + input.triggerRect.width / 2 - input.contentWidth / 2;
+  const maxLeft = viewportWidth - padding - input.contentWidth;
+  if (left < padding) {
+    left = padding;
+  } else if (left > maxLeft) {
+    left = Math.max(padding, maxLeft);
+  }
+  let clampedTop = top;
+  const maxTop = viewportHeight - padding - input.contentHeight;
+  if (clampedTop < padding) {
+    clampedTop = padding;
+  } else if (clampedTop > maxTop) {
+    clampedTop = Math.max(padding, maxTop);
+  }
+  return { top: clampedTop, left, side };
+}
+var init_compute_tooltip_placement = __esm({
+  "src/features/file-viewer/primitives/compute-tooltip-placement.ts"() {
+  }
+});
+function useTooltipGroup() {
+  const context = useContext(TooltipGroupContext);
+  if (!context) {
+    throw new Error("Tooltip components must be used within TooltipProvider");
+  }
+  return context;
+}
+function useCloseActiveTooltip() {
+  const context = useContext(TooltipGroupContext);
+  return context?.closeActiveTooltip ?? (() => void 0);
+}
+function TooltipProvider({
+  children,
+  delayDuration = 300,
+  skipDelayDuration = 500,
+  closeDelayDuration = DEFAULT_CLOSE_DELAY_MS
+}) {
+  const isOpenDelayedRef = useRef(true);
+  const skipDelayTimerRef = useRef(null);
+  const activeCloseRef = useRef(null);
+  const onTooltipOpened = useCallback(() => {
+    if (skipDelayTimerRef.current !== null) {
+      window.clearTimeout(skipDelayTimerRef.current);
+    }
+    isOpenDelayedRef.current = false;
+    skipDelayTimerRef.current = window.setTimeout(() => {
+      isOpenDelayedRef.current = true;
+      skipDelayTimerRef.current = null;
+    }, skipDelayDuration);
+  }, [skipDelayDuration]);
+  const getOpenDelay = useCallback(
+    () => isOpenDelayedRef.current ? delayDuration : 0,
+    [delayDuration]
+  );
+  const requestExclusiveOpen = useCallback((closeCallback) => {
+    activeCloseRef.current?.();
+    activeCloseRef.current = closeCallback;
+  }, []);
+  const releaseExclusiveOpen = useCallback((closeCallback) => {
+    if (activeCloseRef.current === closeCallback) {
+      activeCloseRef.current = null;
+    }
+  }, []);
+  const closeActiveTooltip = useCallback(() => {
+    activeCloseRef.current?.();
+    activeCloseRef.current = null;
+  }, []);
+  useEffect(
+    () => () => {
+      if (skipDelayTimerRef.current !== null) {
+        window.clearTimeout(skipDelayTimerRef.current);
+      }
+    },
+    []
+  );
+  useEffect(() => {
+    const handleDismiss = () => closeActiveTooltip();
+    const handlePointerOut = (event) => {
+      if (event.pointerType !== "mouse") return;
+      const related = event.relatedTarget;
+      if (related instanceof Node && document.documentElement.contains(related)) {
+        return;
+      }
+      closeActiveTooltip();
+    };
+    window.addEventListener("blur", handleDismiss);
+    window.addEventListener("scroll", handleDismiss, true);
+    document.documentElement.addEventListener("pointerout", handlePointerOut);
+    return () => {
+      window.removeEventListener("blur", handleDismiss);
+      window.removeEventListener("scroll", handleDismiss, true);
+      document.documentElement.removeEventListener("pointerout", handlePointerOut);
+    };
+  }, [closeActiveTooltip]);
+  return /* @__PURE__ */ jsx(
+    TooltipGroupContext.Provider,
+    {
+      value: {
+        delayDuration,
+        skipDelayDuration,
+        closeDelayDuration,
+        getOpenDelay,
+        onTooltipOpened,
+        closeActiveTooltip,
+        requestExclusiveOpen,
+        releaseExclusiveOpen
+      },
+      children
+    }
+  );
+}
+function useTooltipRoot() {
+  const context = useContext(TooltipRootContext);
+  if (!context) {
+    throw new Error("Tooltip components must be used within TooltipRoot");
+  }
+  return context;
+}
+function TooltipRoot({ children }) {
+  const group = useTooltipGroup();
+  const [open, setOpen] = useState(false);
+  const triggerRef = useRef(null);
+  const contentId = useId();
+  const openTimerRef = useRef(null);
+  const closeTimerRef = useRef(null);
+  const closeTooltip = useCallback(() => {
+    setOpen(false);
+    group.releaseExclusiveOpen(closeTooltip);
+  }, [group]);
+  const clearTimers = useCallback(() => {
+    if (openTimerRef.current !== null) {
+      window.clearTimeout(openTimerRef.current);
+      openTimerRef.current = null;
+    }
+    if (closeTimerRef.current !== null) {
+      window.clearTimeout(closeTimerRef.current);
+      closeTimerRef.current = null;
+    }
+  }, []);
+  const openImmediately = useCallback(() => {
+    clearTimers();
+    group.requestExclusiveOpen(closeTooltip);
+    setOpen(true);
+    group.onTooltipOpened();
+  }, [clearTimers, closeTooltip, group]);
+  const scheduleOpen = useCallback(() => {
+    clearTimers();
+    const delay = group.getOpenDelay();
+    openTimerRef.current = window.setTimeout(() => {
+      openImmediately();
+      openTimerRef.current = null;
+    }, delay);
+  }, [clearTimers, group, openImmediately]);
+  const scheduleClose = useCallback(() => {
+    clearTimers();
+    closeTimerRef.current = window.setTimeout(() => {
+      closeTooltip();
+      closeTimerRef.current = null;
+    }, group.closeDelayDuration);
+  }, [clearTimers, closeTooltip, group.closeDelayDuration]);
+  useEffect(() => {
+    return () => {
+      clearTimers();
+      group.releaseExclusiveOpen(closeTooltip);
+    };
+  }, [clearTimers, closeTooltip, group]);
+  return /* @__PURE__ */ jsx(
+    TooltipRootContext.Provider,
+    {
+      value: {
+        open,
+        triggerRef,
+        contentId,
+        scheduleOpen,
+        scheduleClose,
+        openImmediately
+      },
+      children
+    }
+  );
+}
+function TooltipTrigger({
+  asChild,
+  children
+}) {
+  const {
+    open,
+    triggerRef,
+    scheduleOpen,
+    scheduleClose,
+    openImmediately,
+    contentId
+  } = useTooltipRoot();
+  const triggerProps = {
+    ref: (node) => {
+      triggerRef.current = node;
+    },
+    "aria-describedby": open ? contentId : void 0,
+    onMouseEnter: () => scheduleOpen(),
+    onMouseLeave: () => scheduleClose(),
+    onFocus: () => openImmediately(),
+    onBlur: () => scheduleClose()
+  };
+  if (asChild) {
+    return renderAsChild(true, children, triggerProps);
+  }
+  return /* @__PURE__ */ jsx("span", { ...triggerProps, children });
+}
+function TooltipPortal({ children }) {
+  const { open } = useTooltipRoot();
+  if (!open || typeof document === "undefined") return null;
+  return createPortal(children, document.body);
+}
+function TooltipContent({
+  children,
+  side: preferredSide = "top",
+  sideOffset = 6,
+  className,
+  style
+}) {
+  const { open, triggerRef, contentId } = useTooltipRoot();
+  const contentRef = useRef(null);
+  const [placement, setPlacement] = useState(null);
+  useLayoutEffect(() => {
+    if (!open) {
+      setPlacement(null);
+      return;
+    }
+    const updatePlacement = () => {
+      const trigger = triggerRef.current;
+      const content = contentRef.current;
+      if (!trigger || !content) return;
+      const triggerRect = trigger.getBoundingClientRect();
+      const { width, height } = content.getBoundingClientRect();
+      if (width === 0 || height === 0) {
+        requestAnimationFrame(updatePlacement);
+        return;
+      }
+      setPlacement(
+        computeTooltipPlacement({
+          triggerRect,
+          contentWidth: width,
+          contentHeight: height,
+          preferredSide,
+          sideOffset
+        })
+      );
+    };
+    updatePlacement();
+    window.addEventListener("scroll", updatePlacement, true);
+    window.addEventListener("resize", updatePlacement);
+    return () => {
+      window.removeEventListener("scroll", updatePlacement, true);
+      window.removeEventListener("resize", updatePlacement);
+    };
+  }, [open, preferredSide, sideOffset, triggerRef]);
+  if (!open) return null;
+  const isPositioned = placement !== null;
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref: contentRef,
+      id: contentId,
+      role: "tooltip",
+      className: [TOOLTIP_CONTENT_BASE, className].filter(Boolean).join(" "),
+      style: {
+        top: placement?.top ?? -9999,
+        left: placement?.left ?? -9999,
+        visibility: isPositioned ? "visible" : "hidden",
+        opacity: isPositioned ? 1 : 0,
+        ...style
+      },
+      children
+    }
+  );
+}
+var TooltipGroupContext, DEFAULT_CLOSE_DELAY_MS, TooltipRootContext, TOOLTIP_CONTENT_BASE;
+var init_tooltip = __esm({
+  "src/features/file-viewer/primitives/tooltip.tsx"() {
+    init_as_child();
+    init_compute_tooltip_placement();
+    TooltipGroupContext = createContext(null);
+    DEFAULT_CLOSE_DELAY_MS = 0;
+    TooltipRootContext = createContext(null);
+    TOOLTIP_CONTENT_BASE = "pointer-events-none fixed z-[200] w-max max-w-xs transition-opacity duration-200";
+  }
+});
+function FileViewerTooltipProvider({
+  children
+}) {
+  const tooltipDefaults = getFileViewerDefaults().tooltip;
+  return /* @__PURE__ */ jsx(
+    TooltipProvider,
+    {
+      delayDuration: tooltipDefaults?.delayDuration ?? 300,
+      skipDelayDuration: tooltipDefaults?.skipDelayDuration ?? 500,
+      children
+    }
+  );
+}
+function TooltipDisabledTarget({ children }) {
+  const closeActiveTooltip = useCloseActiveTooltip();
+  return renderAsChild(true, children, {
+    className: "pointer-events-auto",
+    onMouseEnter: () => closeActiveTooltip(),
+    onFocus: () => closeActiveTooltip()
+  });
+}
+function FileViewerTooltip({
+  content,
+  children,
+  disabled = false,
+  classNames,
+  styles
+}) {
+  if (disabled) {
+    return /* @__PURE__ */ jsx(TooltipDisabledTarget, { children });
+  }
+  const tooltipDefaults = getFileViewerDefaults().tooltip;
+  return /* @__PURE__ */ jsxs(TooltipRoot, { children: [
+    /* @__PURE__ */ jsx(TooltipTrigger, { asChild: true, children }),
+    /* @__PURE__ */ jsx(TooltipPortal, { children: /* @__PURE__ */ jsx(
+      TooltipContent,
+      {
+        side: "top",
+        sideOffset: 6,
+        className: mergeClassNames(
+          FILE_VIEWER_TOOLTIP_CONTENT_DEFAULT,
+          tooltipDefaults?.classNames?.content,
+          classNames?.content
+        ),
+        style: mergeStyles(
+          tooltipDefaults?.styles?.content,
+          styles?.content
+        ),
+        children: content
+      }
+    ) })
+  ] });
+}
+var FILE_VIEWER_TOOLTIP_CONTENT_DEFAULT;
+var init_FileViewerTooltip = __esm({
+  "src/features/file-viewer/components/FileViewerTooltip.tsx"() {
+    init_config();
+    init_tooltip();
+    init_as_child();
+    init_merge_slot_props();
+    FILE_VIEWER_TOOLTIP_CONTENT_DEFAULT = "select-none rounded-md border border-neutral-700/50 bg-neutral-900/75 px-2 py-1.5 text-xs text-white/90 shadow-lg backdrop-blur-sm";
+  }
+});
+
+// src/features/file-viewer/translations.ts
+function applyTranslationOverlay(builtIn, overlay) {
+  if (!overlay) return builtIn;
+  return {
+    fileViewer: { ...builtIn.fileViewer, ...overlay.fileViewer },
+    imageViewer: { ...builtIn.imageViewer, ...overlay.imageViewer },
+    pdfViewer: { ...builtIn.pdfViewer, ...overlay.pdfViewer }
+  };
+}
+function getFileViewerTranslations(language) {
+  const builtIn = fileViewerTranslationsByLanguage[language];
+  const overlay = getFileViewerDefaults().translations?.[language];
+  if (!overlay) {
+    return builtIn;
+  }
+  return applyTranslationOverlay(
+    builtIn,
+    overlay
+  );
+}
+function resolveFormattedMessage(message, params) {
+  return typeof message === "function" ? message(params) : message;
+}
+var fileViewerTranslationsByLanguage, defaultFileViewerTranslations;
+var init_translations = __esm({
+  "src/features/file-viewer/translations.ts"() {
+    init_config();
+    fileViewerTranslationsByLanguage = {
+      english: {
+        fileViewer: {
+          closeAriaLabel: "Close",
+          printAriaLabel: "Print",
+          printTooltip: "Print",
+          downloadAriaLabel: "Download",
+          downloadTooltip: "Download",
+          downloadInProgressAriaLabel: "Downloading\u2026",
+          downloadInProgressTooltip: "Downloading\u2026",
+          openInModalAriaLabel: "Open in full screen",
+          openInModalTooltip: "Open in full screen",
+          unsupportedFileType: ({ extension }) => `No preview is available for file type "${extension}".`
+        },
+        imageViewer: {
+          zoomOutAriaLabel: "Zoom out",
+          fitScreenAriaLabel: "Fit image",
+          zoomInAriaLabel: "Zoom in",
+          zoomOutTooltip: "Zoom out",
+          fitScreenTooltip: "Fit image",
+          zoomInTooltip: "Zoom in"
+        },
+        pdfViewer: {
+          pageLabel: "Page",
+          pageInputAriaLabel: ({ value }) => `Page ${value}`,
+          previousPageAriaLabel: "Previous page",
+          nextPageAriaLabel: "Next page",
+          previousPageTooltip: "Previous page",
+          nextPageTooltip: "Next page",
+          zoomOutAriaLabel: "Zoom out",
+          fitWidthAriaLabel: "Fit width",
+          zoomInAriaLabel: "Zoom in",
+          zoomOutTooltip: "Zoom out",
+          fitWidthTooltip: "Fit width",
+          zoomInTooltip: "Zoom in"
+        }
+      },
+      portuguese: {
+        fileViewer: {
+          closeAriaLabel: "Fechar",
+          printAriaLabel: "Imprimir",
+          printTooltip: "Imprimir",
+          downloadAriaLabel: "Transferir",
+          downloadTooltip: "Transferir",
+          downloadInProgressAriaLabel: "A transferir\u2026",
+          downloadInProgressTooltip: "A transferir\u2026",
+          openInModalAriaLabel: "Visualizar em tela cheia",
+          openInModalTooltip: "Visualizar em tela cheia",
+          unsupportedFileType: ({ extension }) => `Ainda n\xE3o existem visualiza\xE7\xF5es para arquivos do tipo "${extension}".`
+        },
+        imageViewer: {
+          zoomOutAriaLabel: "Diminuir zoom",
+          fitScreenAriaLabel: "Ajustar imagem",
+          zoomInAriaLabel: "Aumentar zoom",
+          zoomOutTooltip: "Diminuir zoom",
+          fitScreenTooltip: "Ajustar imagem",
+          zoomInTooltip: "Aumentar zoom"
+        },
+        pdfViewer: {
+          pageLabel: "P\xE1gina",
+          pageInputAriaLabel: ({ value }) => `P\xE1gina ${value}`,
+          previousPageAriaLabel: "P\xE1gina anterior",
+          nextPageAriaLabel: "Pr\xF3xima p\xE1gina",
+          previousPageTooltip: "P\xE1gina anterior",
+          nextPageTooltip: "Pr\xF3xima p\xE1gina",
+          zoomOutAriaLabel: "Diminuir zoom",
+          fitWidthAriaLabel: "Ajustar \xE0 largura",
+          zoomInAriaLabel: "Aumentar zoom",
+          zoomOutTooltip: "Diminuir zoom",
+          fitWidthTooltip: "Ajustar \xE0 largura",
+          zoomInTooltip: "Aumentar zoom"
+        }
+      }
+    };
+    defaultFileViewerTranslations = fileViewerTranslationsByLanguage.english;
+  }
+});
+
+// src/features/file-viewer/utils/resolve-options.ts
+function resolveOption(instance, global, builtIn) {
+  if (instance !== void 0) {
+    return instance;
+  }
+  if (global !== void 0) {
+    return global;
+  }
+  return builtIn;
+}
+function resolveHideCloseButton(instance, global, mode) {
+  if (instance !== void 0) {
+    return instance;
+  }
+  if (global !== void 0) {
+    return global;
+  }
+  return mode === "inline";
+}
+var init_resolve_options = __esm({
+  "src/features/file-viewer/utils/resolve-options.ts"() {
+  }
+});
+
+// src/features/file-viewer/primitives/scroll-area-math.ts
+function getThumbRatio(viewportSize, contentSize) {
+  const ratio = viewportSize / contentSize;
+  return Number.isNaN(ratio) ? 0 : ratio;
+}
+function getThumbSize(sizes) {
+  const ratio = getThumbRatio(sizes.viewport, sizes.content);
+  const scrollbarPadding = sizes.scrollbar.paddingStart + sizes.scrollbar.paddingEnd;
+  const thumbSize = (sizes.scrollbar.size - scrollbarPadding) * ratio;
+  return Math.max(thumbSize, 18);
+}
+function hasScrollAreaThumb(sizes) {
+  if (sizes.viewport <= 0 || sizes.content <= 0 || sizes.scrollbar.size <= 0) {
+    return false;
+  }
+  return sizes.content > sizes.viewport + 1;
+}
+function clamp(value, [min, max]) {
+  return Math.min(Math.max(value, min), max);
+}
+function linearScale(input, output) {
+  return (value) => {
+    if (input[0] === input[1] || output[0] === output[1]) return output[0];
+    const ratio = (output[1] - output[0]) / (input[1] - input[0]);
+    return output[0] + ratio * (value - input[0]);
+  };
+}
+function getThumbOffsetFromScroll(scrollPos, sizes) {
+  const thumbSizePx = getThumbSize(sizes);
+  const scrollbarPadding = sizes.scrollbar.paddingStart + sizes.scrollbar.paddingEnd;
+  const scrollbarTrack = sizes.scrollbar.size - scrollbarPadding;
+  const maxScrollPos = sizes.content - sizes.viewport;
+  const maxThumbPos = scrollbarTrack - thumbSizePx;
+  const scrollWithoutMomentum = clamp(scrollPos, [0, maxScrollPos]);
+  const interpolate = linearScale([0, maxScrollPos], [0, maxThumbPos]);
+  return interpolate(scrollWithoutMomentum);
+}
+function getScrollPositionFromPointer(pointerPos, pointerOffset, sizes) {
+  const thumbSizePx = getThumbSize(sizes);
+  const thumbCenter = thumbSizePx / 2;
+  const offset = pointerOffset || thumbCenter;
+  const thumbOffsetFromEnd = thumbSizePx - offset;
+  const minPointerPos = sizes.scrollbar.paddingStart + offset;
+  const maxPointerPos = sizes.scrollbar.size - sizes.scrollbar.paddingEnd - thumbOffsetFromEnd;
+  const maxScrollPos = sizes.content - sizes.viewport;
+  const interpolate = linearScale([minPointerPos, maxPointerPos], [0, maxScrollPos]);
+  return interpolate(pointerPos);
+}
+var init_scroll_area_math = __esm({
+  "src/features/file-viewer/primitives/scroll-area-math.ts"() {
+  }
+});
+function useScrollAreaContext(component) {
+  const context = useContext(ScrollAreaContext);
+  if (!context) {
+    throw new Error(`${component} must be used within ScrollAreaRoot`);
+  }
+  return context;
+}
+function assignRef2(ref, value) {
+  if (typeof ref === "function") {
+    ref(value);
+    return;
+  }
+  if (ref && typeof ref === "object") {
+    ref.current = value;
+  }
+}
+function mergeRefs2(...refs) {
+  return (value) => {
+    refs.forEach((ref) => assignRef2(ref, value));
+  };
+}
+function readScrollbarPadding(track) {
+  const computed = getComputedStyle(track);
+  return {
+    paddingStart: Number.parseInt(computed.paddingTop, 10) || 0,
+    paddingEnd: Number.parseInt(computed.paddingBottom, 10) || 0,
+    paddingLeft: Number.parseInt(computed.paddingLeft, 10) || 0,
+    paddingRight: Number.parseInt(computed.paddingRight, 10) || 0
+  };
+}
+function ScrollAreaRoot({
+  className,
+  style,
+  children,
+  ...rest
+}) {
+  const viewportRef = useRef(null);
+  const [cornerWidth, setCornerWidth] = useState(0);
+  const [cornerHeight, setCornerHeight] = useState(0);
+  return /* @__PURE__ */ jsx(
+    ScrollAreaContext.Provider,
+    {
+      value: {
+        viewportRef,
+        cornerWidth,
+        cornerHeight,
+        setCornerWidth,
+        setCornerHeight
+      },
+      children: /* @__PURE__ */ jsx(
+        "div",
+        {
+          className,
+          style: {
+            position: "relative",
+            overflow: "hidden",
+            ["--scroll-area-corner-width"]: `${cornerWidth}px`,
+            ["--scroll-area-corner-height"]: `${cornerHeight}px`,
+            ...style
+          },
+          ...rest,
+          children
+        }
+      )
+    }
+  );
+}
+function ScrollAreaScrollbar({
+  orientation,
+  className,
+  style,
+  children,
+  ...rest
+}) {
+  const context = useScrollAreaContext("ScrollAreaScrollbar");
+  const trackRef = useRef(null);
+  const thumbRef = useRef(null);
+  const pointerOffsetRef = useRef(0);
+  const [sizes, setSizes] = useState(EMPTY_SIZES);
+  const isVertical = orientation === "vertical";
+  const showThumb = hasScrollAreaThumb(sizes);
+  const updateSizes = useCallback(() => {
+    const viewport = context.viewportRef.current;
+    const track = trackRef.current;
+    if (!viewport || !track) return;
+    const padding = readScrollbarPadding(track);
+    if (isVertical) {
+      setSizes({
+        content: viewport.scrollHeight,
+        viewport: viewport.offsetHeight,
+        scrollbar: {
+          size: track.clientHeight,
+          paddingStart: padding.paddingStart,
+          paddingEnd: padding.paddingEnd
+        }
+      });
+      context.setCornerWidth(track.offsetWidth);
+      return;
+    }
+    setSizes({
+      content: viewport.scrollWidth,
+      viewport: viewport.offsetWidth,
+      scrollbar: {
+        size: track.clientWidth,
+        paddingStart: padding.paddingLeft,
+        paddingEnd: padding.paddingRight
+      }
+    });
+    context.setCornerHeight(track.offsetHeight);
+  }, [context, isVertical]);
+  const updateThumbPosition = useCallback(() => {
+    const viewport = context.viewportRef.current;
+    const thumb = thumbRef.current;
+    if (!viewport || !thumb || !showThumb) return;
+    const scrollPos = isVertical ? viewport.scrollTop : viewport.scrollLeft;
+    const offset = getThumbOffsetFromScroll(scrollPos, sizes);
+    thumb.style.transform = isVertical ? `translate3d(0, ${offset}px, 0)` : `translate3d(${offset}px, 0, 0)`;
+  }, [context.viewportRef, isVertical, showThumb, sizes]);
+  useEffect(() => {
+    const viewport = context.viewportRef.current;
+    const track = trackRef.current;
+    if (!viewport || !track) return;
+    const runUpdate = () => {
+      requestAnimationFrame(updateSizes);
+    };
+    runUpdate();
+    const resizeObserver = new ResizeObserver(runUpdate);
+    resizeObserver.observe(viewport);
+    resizeObserver.observe(track);
+    const contentRoot = viewport.firstElementChild;
+    if (contentRoot) {
+      resizeObserver.observe(contentRoot);
+    }
+    const mutationObserver = new MutationObserver(runUpdate);
+    mutationObserver.observe(viewport, {
+      childList: true,
+      subtree: true,
+      attributes: true
+    });
+    return () => {
+      resizeObserver.disconnect();
+      mutationObserver.disconnect();
+    };
+  }, [context.viewportRef, updateSizes]);
+  useEffect(() => {
+    updateThumbPosition();
+  }, [sizes, updateThumbPosition]);
+  useEffect(() => {
+    const viewport = context.viewportRef.current;
+    if (!viewport) return;
+    let frame = 0;
+    const handleScroll = () => {
+      if (frame) cancelAnimationFrame(frame);
+      frame = requestAnimationFrame(() => {
+        updateThumbPosition();
+        frame = 0;
+      });
+    };
+    viewport.addEventListener("scroll", handleScroll, { passive: true });
+    return () => {
+      viewport.removeEventListener("scroll", handleScroll);
+      if (frame) cancelAnimationFrame(frame);
+    };
+  }, [context.viewportRef, updateThumbPosition]);
+  const getPointerOnTrack = useCallback(
+    (clientX, clientY) => {
+      const track = trackRef.current;
+      if (!track) return 0;
+      const rect = track.getBoundingClientRect();
+      return isVertical ? clientY - rect.top : clientX - rect.left;
+    },
+    [isVertical]
+  );
+  const setScrollFromPointer = useCallback(
+    (pointerPos) => {
+      const viewport = context.viewportRef.current;
+      if (!viewport) return;
+      const scrollPos = getScrollPositionFromPointer(
+        pointerPos,
+        pointerOffsetRef.current,
+        sizes
+      );
+      if (isVertical) {
+        viewport.scrollTop = scrollPos;
+      } else {
+        viewport.scrollLeft = scrollPos;
+      }
+    },
+    [context.viewportRef, isVertical, sizes]
+  );
+  const handleTrackPointerDown = (event) => {
+    if (event.button !== 0) return;
+    const track = trackRef.current;
+    if (!track) return;
+    if (event.target === track) {
+      pointerOffsetRef.current = 0;
+    }
+    event.currentTarget.setPointerCapture(event.pointerId);
+    setScrollFromPointer(getPointerOnTrack(event.clientX, event.clientY));
+  };
+  const handleTrackPointerMove = (event) => {
+    if (!event.currentTarget.hasPointerCapture(event.pointerId)) {
+      return;
+    }
+    setScrollFromPointer(getPointerOnTrack(event.clientX, event.clientY));
+  };
+  const handleTrackPointerUp = (event) => {
+    if (event.currentTarget.hasPointerCapture(event.pointerId)) {
+      event.currentTarget.releasePointerCapture(event.pointerId);
+    }
+    pointerOffsetRef.current = 0;
+  };
+  const thumbProps = children.props;
+  const thumbClassName = thumbProps.className;
+  const thumbStyleProp = thumbProps.style;
+  const {
+    className: _ignoredClassName,
+    style: _ignoredStyle,
+    ...thumbRest
+  } = thumbProps;
+  const thumbSizePx = getThumbSize(sizes);
+  const thumbDimensionStyle = isVertical ? { height: thumbSizePx, width: "100%" } : { width: thumbSizePx, height: "100%" };
+  const trackStyle = isVertical ? {
+    position: "absolute",
+    top: 0,
+    right: 0,
+    bottom: "var(--scroll-area-corner-height)"
+  } : {
+    position: "absolute",
+    bottom: 0,
+    left: 0,
+    right: "var(--scroll-area-corner-width)"
+  };
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref: trackRef,
+      "data-orientation": orientation,
+      className,
+      style: { ...trackStyle, ...style },
+      onPointerDown: handleTrackPointerDown,
+      onPointerMove: handleTrackPointerMove,
+      onPointerUp: handleTrackPointerUp,
+      onPointerCancel: handleTrackPointerUp,
+      ...rest,
+      children: showThumb ? /* @__PURE__ */ jsx(
+        "div",
+        {
+          ref: thumbRef,
+          "data-state": "visible",
+          className: thumbClassName,
+          style: {
+            flex: "none",
+            ...thumbDimensionStyle,
+            ...thumbStyleProp
+          },
+          onPointerDownCapture: (event) => {
+            thumbProps.onPointerDownCapture?.(event);
+            const thumbRect = event.currentTarget.getBoundingClientRect();
+            pointerOffsetRef.current = isVertical ? event.clientY - thumbRect.top : event.clientX - thumbRect.left;
+          },
+          ...thumbRest
+        }
+      ) : null
+    }
+  );
+}
+function ScrollAreaThumb({ className, style, ...rest }) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      "data-state": "hidden",
+      className,
+      style,
+      ...rest
+    }
+  );
+}
+function ScrollAreaCorner({ className, style, ...rest }) {
+  const { cornerWidth, cornerHeight } = useScrollAreaContext("ScrollAreaCorner");
+  if (!cornerWidth || !cornerHeight) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className,
+      style: {
+        position: "absolute",
+        right: 0,
+        bottom: 0,
+        width: cornerWidth,
+        height: cornerHeight,
+        ...style
+      },
+      ...rest
+    }
+  );
+}
+var EMPTY_SIZES, ScrollAreaContext, ScrollAreaViewport;
+var init_scroll_area = __esm({
+  "src/features/file-viewer/primitives/scroll-area.tsx"() {
+    init_merge_slot_props();
+    init_scroll_area_math();
+    EMPTY_SIZES = {
+      content: 0,
+      viewport: 0,
+      scrollbar: { size: 0, paddingStart: 0, paddingEnd: 0 }
+    };
+    ScrollAreaContext = createContext(null);
+    ScrollAreaViewport = forwardRef(
+      ({ className, children, onScroll, ...rest }, forwardedRef) => {
+        const { viewportRef } = useScrollAreaContext("ScrollAreaViewport");
+        return /* @__PURE__ */ jsx(
+          "div",
+          {
+            ref: mergeRefs2(forwardedRef, viewportRef),
+            onScroll,
+            className: mergeClassNames(
+              "size-full overflow-x-scroll overflow-y-scroll pdf-scroll-viewport",
+              className
+            ),
+            ...rest,
+            children: /* @__PURE__ */ jsx(
+              "div",
+              {
+                className: "scroll-area-viewport-inner",
+                style: { minWidth: "100%", display: "table" },
+                children
+              }
+            )
+          }
+        );
+      }
+    );
+    ScrollAreaViewport.displayName = "ScrollAreaViewport";
+  }
+});
+
+// src/features/file-viewer/pdf-viewer.css
+var init_pdf_viewer = __esm({
+  "src/features/file-viewer/pdf-viewer.css"() {
+  }
+});
+function ViewerToolbarDivider({
+  className = "",
+  style,
+  classNames,
+  styles
+}) {
+  const globalToolbar = getFileViewerDefaults().toolbar;
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: mergeClassNames(
+        VIEWER_TOOLBAR_DIVIDER_DEFAULT,
+        globalToolbar?.classNames?.divider,
+        classNames?.divider,
+        className
+      ),
+      style: mergeStyles(globalToolbar?.styles?.divider, styles?.divider, style),
+      "aria-hidden": true
+    }
+  );
+}
+function ViewerToolbarIconButton({
+  className = "",
+  style,
+  classNames,
+  styles,
+  ...rest
+}) {
+  const globalToolbar = getFileViewerDefaults().toolbar;
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      className: mergeClassNames(
+        VIEWER_TOOLBAR_ICON_BUTTON_DEFAULT,
+        globalToolbar?.classNames?.iconButton,
+        classNames?.iconButton,
+        className
+      ),
+      style: mergeStyles(
+        globalToolbar?.styles?.iconButton,
+        styles?.iconButton,
+        style
+      ),
+      ...rest
+    }
+  );
+}
+var VIEWER_TOOLBAR_DEFAULT, VIEWER_TOOLBAR_DIVIDER_DEFAULT, VIEWER_TOOLBAR_ICON_BUTTON_DEFAULT, ViewerFloatingToolbar;
+var init_ViewerToolbar = __esm({
+  "src/features/file-viewer/components/ViewerToolbar.tsx"() {
+    init_config();
+    init_merge_slot_props();
+    VIEWER_TOOLBAR_DEFAULT = "absolute bottom-4 left-1/2 z-10 flex h-[3.25rem] -translate-x-1/2 items-center gap-2 rounded-full border border-neutral-700/50 bg-neutral-900/60 px-4 text-white/90 shadow-lg backdrop-blur-sm transition-opacity duration-300";
+    VIEWER_TOOLBAR_DIVIDER_DEFAULT = "mx-1 h-full w-px bg-white/20";
+    VIEWER_TOOLBAR_ICON_BUTTON_DEFAULT = "cursor-pointer rounded-full p-2 text-white/70 transition-colors hover:bg-white/10 hover:text-white disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-40 disabled:hover:bg-transparent disabled:hover:text-white/40";
+    ViewerFloatingToolbar = forwardRef(({ children, className = "", style, classNames, styles }, ref) => {
+      const globalToolbar = getFileViewerDefaults().toolbar;
+      return /* @__PURE__ */ jsx(
+        "div",
+        {
+          ref,
+          className: mergeClassNames(
+            VIEWER_TOOLBAR_DEFAULT,
+            globalToolbar?.classNames?.toolbar,
+            classNames?.toolbar,
+            className
+          ),
+          style: mergeStyles(globalToolbar?.styles?.toolbar, styles?.toolbar, style),
+          children
+        }
+      );
+    });
+    ViewerFloatingToolbar.displayName = "ViewerFloatingToolbar";
+  }
+});
+function getDistanceToElement(x, y, element) {
+  const rect = element.getBoundingClientRect();
+  const dx = Math.max(rect.left - x, 0, x - rect.right);
+  const dy = Math.max(rect.top - y, 0, y - rect.bottom);
+  return Math.sqrt(dx * dx + dy * dy);
+}
+function useAutoHide(targetRef, containerRef, options = {}) {
+  const { proximityThreshold = 160, timeout = 3e3, activityDeps = [] } = options;
+  const [isVisible, setIsVisible] = useState(true);
+  const timerRef = useRef(null);
+  const isNearRef = useRef(false);
+  const startTimer = () => {
+    if (timerRef.current !== null) {
+      window.clearTimeout(timerRef.current);
+    }
+    timerRef.current = window.setTimeout(() => {
+      setIsVisible(false);
+      timerRef.current = null;
+    }, timeout);
+  };
+  useEffect(() => {
+    setIsVisible(true);
+    if (!isNearRef.current) {
+      startTimer();
+    }
+    return () => {
+      if (timerRef.current !== null) {
+        window.clearTimeout(timerRef.current);
+        timerRef.current = null;
+      }
+    };
+  }, activityDeps);
+  useEffect(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const handleMouseMove = (e) => {
+      if (!targetRef.current) return;
+      const distance = getDistanceToElement(e.clientX, e.clientY, targetRef.current);
+      const isNear = distance <= proximityThreshold;
+      if (isNear) {
+        setIsVisible(true);
+        if (timerRef.current !== null) {
+          window.clearTimeout(timerRef.current);
+          timerRef.current = null;
+        }
+      } else {
+        if (isNearRef.current) {
+          startTimer();
+        }
+      }
+      isNearRef.current = isNear;
+    };
+    const handleMouseLeave = () => {
+      isNearRef.current = false;
+      startTimer();
+    };
+    container.addEventListener("mousemove", handleMouseMove);
+    container.addEventListener("mouseleave", handleMouseLeave);
+    return () => {
+      container.removeEventListener("mousemove", handleMouseMove);
+      container.removeEventListener("mouseleave", handleMouseLeave);
+    };
+  }, [proximityThreshold, timeout, targetRef, containerRef]);
+  return isVisible;
+}
+var init_useAutoHide = __esm({
+  "src/features/file-viewer/hooks/useAutoHide.ts"() {
+  }
+});
+
+// src/features/file-viewer/PdfViewer.tsx
+var PdfViewer_exports = {};
+__export(PdfViewer_exports, {
+  default: () => PdfViewer
+});
+function PdfViewer(props) {
+  const { url, language: languageProp, ...instanceProps } = props;
+  const resolved = resolvePdfViewerProps(instanceProps);
+  const viewMode = resolved.viewMode ?? "continuous";
+  const debounceDelay = resolved.debounceDelay ?? 300;
+  const zoomDebounceDelay = resolved.zoomDebounceDelay ?? 500;
+  const renderTextLayer = resolved.renderTextLayer ?? true;
+  const renderAnnotationLayer = resolved.renderAnnotationLayer ?? true;
+  const renderLoading = resolved.renderLoading ?? null;
+  const preloadAhead = resolved.preloadAhead ?? 1;
+  const onLoadSuccess = resolved.onLoadSuccess;
+  const onLoadError = resolved.onLoadError;
+  const onPageChange = resolved.onPageChange;
+  const defaultPage = resolved.defaultPage ?? 1;
+  const renderPagination = resolved.renderPagination;
+  const paginationClassName = resolved.paginationClassName;
+  const className = resolved.className;
+  const pageClassName = resolved.pageClassName;
+  const classNames = resolved.classNames;
+  const styles = resolved.styles;
+  const language = resolveOption(
+    languageProp,
+    getFileViewerDefaults().language,
+    "english"
+  );
+  const pdfT = getFileViewerTranslations(language).pdfViewer;
+  const autoHideDefaults = getFileViewerDefaults().autoHide;
+  const pdfClassName = (key, builtIn, extra) => mergeClassNames(
+    builtIn,
+    classNames?.[key],
+    key === "root" ? className : void 0,
+    key === "page" ? pageClassName : void 0,
+    key === "pagination" ? paginationClassName : void 0,
+    extra
+  );
+  const pdfStyle = (key) => styles?.[key];
+  const [numPages, setNumPages] = useState(0);
+  const [pageNumber, setPageNumber] = useState(defaultPage);
+  const [visibleRange, setVisibleRange] = useState({ start: defaultPage, end: defaultPage });
+  const [inputPage, setInputPage] = useState(String(defaultPage));
+  const containerRef = useRef(null);
+  const toolbarRef = useRef(null);
+  const pageRefs = useRef(/* @__PURE__ */ new Map());
+  const [instantSize, setInstantSize] = useState({ width: 0, height: 0 });
+  const [renderedSize, setRenderedSize] = useState({ width: 0, height: 0 });
+  const [pageOriginalSize, setPageOriginalSize] = useState({
+    width: 0,
+    height: 0
+  });
+  const renderedHeights = useRef(/* @__PURE__ */ new Map());
+  const [instantZoom, setInstantZoom] = useState(1);
+  const [renderedZoom, setRenderedZoom] = useState(1);
+  const isToolbarVisible = useAutoHide(toolbarRef, containerRef, {
+    proximityThreshold: autoHideDefaults?.proximityThreshold,
+    timeout: autoHideDefaults?.timeout,
+    activityDeps: [pageNumber, instantZoom]
+  });
+  const [hasZoomed, setHasZoomed] = useState(false);
+  useEffect(() => {
+    setInstantZoom(1);
+    setRenderedZoom(1);
+    setHasZoomed(false);
+    renderedHeights.current.clear();
+  }, [url, viewMode]);
+  useEffect(() => {
+    if (instantZoom === renderedZoom) return;
+    const timerId = window.setTimeout(() => {
+      setRenderedZoom(instantZoom);
+      renderedHeights.current.clear();
+    }, zoomDebounceDelay);
+    return () => window.clearTimeout(timerId);
+  }, [instantZoom, renderedZoom, zoomDebounceDelay]);
+  const pendingInputPageRef = useRef(null);
+  const pendingInputPageTimerRef = useRef(null);
+  useEffect(() => {
+    const pending = pendingInputPageRef.current;
+    if (pending !== null) {
+      if (pageNumber === pending) {
+        pendingInputPageRef.current = null;
+        if (pendingInputPageTimerRef.current !== null) {
+          window.clearTimeout(pendingInputPageTimerRef.current);
+          pendingInputPageTimerRef.current = null;
+        }
+        setInputPage(String(pageNumber));
+      }
+      return;
+    }
+    setInputPage(String(pageNumber));
+  }, [pageNumber]);
+  useEffect(() => {
+    const updateSize = () => {
+      if (containerRef.current) {
+        const newSize = {
+          width: Math.trunc(containerRef.current.clientWidth),
+          height: Math.trunc(containerRef.current.clientHeight)
+        };
+        setInstantSize((prev) => {
+          if (prev.width === newSize.width && prev.height === newSize.height) return prev;
+          return newSize;
+        });
+        setRenderedSize(
+          (prev) => prev.width === 0 && newSize.width > 0 ? newSize : prev
+        );
+      }
+    };
+    const observer = new ResizeObserver(() => updateSize());
+    if (containerRef.current) observer.observe(containerRef.current);
+    updateSize();
+    return () => observer.disconnect();
+  }, []);
+  useEffect(() => {
+    if (instantSize.width === 0) return;
+    const timerId = window.setTimeout(() => {
+      setRenderedSize(instantSize);
+    }, debounceDelay);
+    return () => window.clearTimeout(timerId);
+  }, [instantSize, debounceDelay]);
+  const calculateDimensions = useCallback(
+    (container) => {
+      if (!container.width || !container.height) {
+        return {
+          width: container.width ? Math.trunc(container.width) : void 0,
+          height: container.height ? Math.trunc(container.height) : void 0
+        };
+      }
+      let remToPx = 16;
+      if (typeof document !== "undefined") {
+        remToPx = parseFloat(getComputedStyle(document.documentElement).fontSize) || 16;
+      }
+      const width = Math.trunc(Math.min(container.width, remToPx * 50));
+      if (!pageOriginalSize.width || !pageOriginalSize.height) {
+        return {
+          width,
+          height: Math.trunc(width * 1.414)
+          // Approximate A4 ratio
+        };
+      }
+      const pageRatio = pageOriginalSize.width / pageOriginalSize.height;
+      return { width, height: Math.trunc(width / pageRatio) };
+    },
+    [pageOriginalSize]
+  );
+  const instantDimensions = useMemo(
+    () => calculateDimensions(instantSize),
+    [calculateDimensions, instantSize]
+  );
+  const renderedDimensions = useMemo(
+    () => calculateDimensions(renderedSize),
+    [calculateDimensions, renderedSize]
+  );
+  const zoomedRenderedDimensions = useMemo(() => {
+    return {
+      width: renderedDimensions.width ? Math.trunc(renderedDimensions.width * renderedZoom) : void 0,
+      height: renderedDimensions.height ? Math.trunc(renderedDimensions.height * renderedZoom) : void 0
+    };
+  }, [renderedDimensions, renderedZoom]);
+  const zoomedInstantDimensions = useMemo(() => {
+    return {
+      width: instantDimensions.width ? Math.trunc(instantDimensions.width * instantZoom) : void 0,
+      height: instantDimensions.height ? Math.trunc(instantDimensions.height * instantZoom) : void 0
+    };
+  }, [instantDimensions, instantZoom]);
+  const layoutScale = useMemo(() => {
+    const renderedWidth = zoomedRenderedDimensions.width;
+    const renderedHeight = zoomedRenderedDimensions.height;
+    const instantWidth = zoomedInstantDimensions.width;
+    const instantHeight = zoomedInstantDimensions.height;
+    if (!renderedWidth || !instantWidth || !instantHeight) {
+      return 1;
+    }
+    if (!renderedHeight) {
+      return Number((instantWidth / renderedWidth).toFixed(4));
+    }
+    return Number(
+      Math.min(
+        instantWidth / renderedWidth,
+        instantHeight / renderedHeight
+      ).toFixed(4)
+    );
+  }, [zoomedInstantDimensions, zoomedRenderedDimensions]);
+  const isLayoutSyncing = useMemo(() => {
+    if (instantZoom !== renderedZoom) return true;
+    if (instantSize.width !== renderedSize.width || instantSize.height !== renderedSize.height) {
+      return true;
+    }
+    return Math.abs(layoutScale - 1) > 1e-3;
+  }, [
+    instantZoom,
+    renderedZoom,
+    instantSize,
+    renderedSize,
+    layoutScale
+  ]);
+  const handleDocumentLoadSuccess = ({
+    numPages: loadedNumPages
+  }) => {
+    setNumPages(loadedNumPages);
+    onLoadSuccess?.(loadedNumPages);
+  };
+  const handleDocumentLoadError = (error) => {
+    console.error(error);
+    onLoadError?.(error);
+  };
+  const handlePageLoadSuccess = (pageIndex, page) => {
+    if (pageIndex === 1) {
+      setPageOriginalSize({
+        width: Math.trunc(page.width),
+        height: Math.trunc(page.height)
+      });
+    }
+    renderedHeights.current.set(pageIndex, Math.trunc(page.height));
+  };
+  const setPage = useCallback(
+    (newPage) => {
+      setPageNumber(newPage);
+      onPageChange?.(newPage);
+    },
+    [onPageChange]
+  );
+  const previousPage = useCallback(() => {
+    if (pendingInputPageRef.current !== null) return;
+    const p = Math.max(pageNumber - 1, 1);
+    if (viewMode === "continuous") {
+      setTimeout(() => {
+        pageRefs.current.get(p)?.scrollIntoView({ behavior: "smooth", block: "start" });
+      }, 10);
+    } else {
+      setPage(p);
+    }
+  }, [pageNumber, viewMode, setPage]);
+  const nextPage = useCallback(() => {
+    if (pendingInputPageRef.current !== null) return;
+    const p = Math.min(pageNumber + 1, numPages || 1);
+    if (viewMode === "continuous") {
+      setTimeout(() => {
+        pageRefs.current.get(p)?.scrollIntoView({ behavior: "smooth", block: "start" });
+      }, 10);
+    } else {
+      setPage(p);
+    }
+  }, [pageNumber, numPages, viewMode, setPage]);
+  const goToPage = useCallback(
+    (p) => {
+      const validPage = Math.max(1, Math.min(p, numPages || 1));
+      if (viewMode === "continuous") {
+        pendingInputPageRef.current = validPage;
+        setInputPage(String(validPage));
+        if (pendingInputPageTimerRef.current !== null) {
+          window.clearTimeout(pendingInputPageTimerRef.current);
+        }
+        pendingInputPageTimerRef.current = window.setTimeout(() => {
+          pendingInputPageRef.current = null;
+          pendingInputPageTimerRef.current = null;
+          setInputPage(String(pageNumberRef.current));
+        }, 750);
+        setTimeout(() => {
+          pageRefs.current.get(validPage)?.scrollIntoView({ behavior: "smooth", block: "start" });
+        }, 10);
+      } else {
+        setPage(validPage);
+      }
+    },
+    [numPages, viewMode, setPage]
+  );
+  const pageNumberRef = useRef(pageNumber);
+  useEffect(() => {
+    pageNumberRef.current = pageNumber;
+  }, [pageNumber]);
+  const CONTINUOUS_PAGE_GAP_PX = 16;
+  const isPreservingScrollRef = useRef(false);
+  const updateVisiblePagesFromScroll = useCallback(() => {
+    const container = containerRef.current;
+    if (!container || viewMode !== "continuous" || numPages <= 0 || isPreservingScrollRef.current) {
+      return;
+    }
+    const scrollTop = container.scrollTop;
+    const viewBottom = scrollTop + container.clientHeight;
+    const defaultPageHeight = zoomedRenderedDimensions.height ?? 0;
+    let offset = 0;
+    let minVisible = Number.POSITIVE_INFINITY;
+    let maxVisible = 0;
+    for (let page = 1; page <= numPages; page++) {
+      const renderedPageHeight = renderedHeights.current.get(page) ?? defaultPageHeight;
+      const slotHeight = Math.trunc(renderedPageHeight * layoutScale);
+      const pageTop = offset;
+      const pageBottom = offset + slotHeight;
+      if (pageBottom > scrollTop && pageTop < viewBottom) {
+        minVisible = Math.min(minVisible, page);
+        maxVisible = Math.max(maxVisible, page);
+      }
+      offset = pageBottom + CONTINUOUS_PAGE_GAP_PX;
+    }
+    if (minVisible === Number.POSITIVE_INFINITY) return;
+    setVisibleRange(
+      (prev) => prev.start !== minVisible || prev.end !== maxVisible ? { start: minVisible, end: maxVisible } : prev
+    );
+  }, [
+    viewMode,
+    numPages,
+    layoutScale,
+    zoomedRenderedDimensions.height
+  ]);
+  useEffect(() => {
+    if (viewMode !== "continuous" || !numPages || !containerRef.current) return;
+    const container = containerRef.current;
+    const handleScroll = () => {
+      requestAnimationFrame(updateVisiblePagesFromScroll);
+    };
+    container.addEventListener("scroll", handleScroll, { passive: true });
+    updateVisiblePagesFromScroll();
+    return () => container.removeEventListener("scroll", handleScroll);
+  }, [numPages, viewMode, updateVisiblePagesFromScroll]);
+  useEffect(() => {
+    if (instantZoom === renderedZoom) {
+      updateVisiblePagesFromScroll();
+    }
+  }, [instantZoom, renderedZoom, updateVisiblePagesFromScroll]);
+  useEffect(() => {
+    if (viewMode !== "continuous" || !numPages || !containerRef.current) return;
+    const ratios = /* @__PURE__ */ new Map();
+    const observer = new IntersectionObserver(
+      (entries) => {
+        for (const entry of entries) {
+          const pStr = entry.target.getAttribute("data-page-number");
+          if (!pStr) continue;
+          const p = parseInt(pStr, 10);
+          if (!Number.isFinite(p)) continue;
+          ratios.set(p, entry.intersectionRatio);
+        }
+        let bestPage = 0;
+        let bestRatio = 0;
+        let minVisible = Infinity;
+        let maxVisible = -Infinity;
+        ratios.forEach((ratio, page) => {
+          if (ratio > 0) {
+            minVisible = Math.min(minVisible, page);
+            maxVisible = Math.max(maxVisible, page);
+          }
+          if (ratio > bestRatio) {
+            bestRatio = ratio;
+            bestPage = page;
+          }
+        });
+        if (bestPage > 0 && bestRatio > 0 && bestPage !== pageNumberRef.current) {
+          setPage(bestPage);
+        }
+        if (minVisible !== Infinity && maxVisible !== -Infinity) {
+          setVisibleRange((prev) => {
+            if (prev.start !== minVisible || prev.end !== maxVisible) {
+              return { start: minVisible, end: maxVisible };
+            }
+            return prev;
+          });
+        }
+      },
+      {
+        root: containerRef.current,
+        threshold: [0, 0.1, 0.25, 0.5, 0.75, 1]
+      }
+    );
+    const currentRefs = pageRefs.current;
+    currentRefs.forEach((ref) => {
+      if (ref) observer.observe(ref);
+    });
+    return () => observer.disconnect();
+  }, [numPages, viewMode, setPage]);
+  const scrollRatioRef = useRef({ x: 0, y: 0 });
+  const zoomAnimFrameRef = useRef(null);
+  useEffect(() => {
+    return () => {
+      if (zoomAnimFrameRef.current !== null) {
+        cancelAnimationFrame(zoomAnimFrameRef.current);
+      }
+    };
+  }, []);
+  const preserveScrollPosition = useCallback(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    isPreservingScrollRef.current = true;
+    const centerY = container.scrollTop + container.clientHeight / 2;
+    const ratioY = container.scrollHeight > 0 ? centerY / container.scrollHeight : 0;
+    const centerX = container.scrollLeft + container.clientWidth / 2;
+    const ratioX = container.scrollWidth > 0 ? centerX / container.scrollWidth : 0;
+    scrollRatioRef.current = { x: ratioX, y: ratioY };
+    if (zoomAnimFrameRef.current !== null) {
+      cancelAnimationFrame(zoomAnimFrameRef.current);
+    }
+    const startTime = performance.now();
+    const duration = 250;
+    const step = (time) => {
+      const currentContainer = containerRef.current;
+      if (!currentContainer) return;
+      const newCenterY = currentContainer.scrollHeight * scrollRatioRef.current.y;
+      const newCenterX = currentContainer.scrollWidth * scrollRatioRef.current.x;
+      currentContainer.scrollTop = newCenterY - currentContainer.clientHeight / 2;
+      currentContainer.scrollLeft = newCenterX - currentContainer.clientWidth / 2;
+      if (time - startTime < duration) {
+        zoomAnimFrameRef.current = requestAnimationFrame(step);
+      } else {
+        zoomAnimFrameRef.current = null;
+        isPreservingScrollRef.current = false;
+      }
+    };
+    zoomAnimFrameRef.current = requestAnimationFrame(step);
+  }, []);
+  const handleZoomIn = useCallback(() => {
+    setHasZoomed(true);
+    preserveScrollPosition();
+    setInstantZoom((prev) => Math.min(prev * 1.3, 4));
+  }, [preserveScrollPosition]);
+  const handleZoomOut = useCallback(() => {
+    setHasZoomed(true);
+    preserveScrollPosition();
+    setInstantZoom((prev) => Math.max(prev / 1.3, 0.5));
+  }, [preserveScrollPosition]);
+  const handleZoomReset = useCallback(() => {
+    setHasZoomed(true);
+    preserveScrollPosition();
+    setInstantZoom(1);
+  }, [preserveScrollPosition]);
+  const zoomOutDisabled = instantZoom <= 0.501;
+  const zoomInDisabled = instantZoom >= 3.99;
+  const fitDisabled = Math.abs(instantZoom - 1) < 0.01;
+  const renderPaginationElement = () => {
+    if (renderPagination === null || numPages <= 1) return null;
+    const props2 = {
+      pageNumber,
+      numPages,
+      previousPage,
+      nextPage,
+      goToPage,
+      isFirstPage: pageNumber <= 1,
+      isLastPage: pageNumber >= numPages,
+      viewMode
+    };
+    if (renderPagination) {
+      return renderPagination(props2);
+    }
+    const paginationBody = /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("div", { className: "bg-black/20 rounded px-1 flex items-center justify-center", children: /* @__PURE__ */ jsx(
+        "input",
+        {
+          type: "text",
+          inputMode: "numeric",
+          value: inputPage,
+          onChange: (event) => setInputPage(event.target.value),
+          onKeyDown: (event) => {
+            if (event.key === "Enter") {
+              const p = parseInt(inputPage, 10);
+              if (!isNaN(p)) goToPage(p);
+            } else if (event.key === "ArrowUp") {
+              event.preventDefault();
+              const p = parseInt(inputPage, 10);
+              if (!isNaN(p)) {
+                setInputPage(String(Math.min(p + 1, numPages)));
+              }
+            } else if (event.key === "ArrowDown") {
+              event.preventDefault();
+              const p = parseInt(inputPage, 10);
+              if (!isNaN(p)) {
+                setInputPage(String(Math.max(p - 1, 1)));
+              }
+            }
+          },
+          onBlur: () => {
+            const p = parseInt(inputPage, 10);
+            if (!isNaN(p)) goToPage(p);
+            else setInputPage(String(pageNumber));
+          },
+          className: pdfClassName("pageInput", PDF_PAGE_INPUT_DEFAULT),
+          style: pdfStyle("pageInput"),
+          "aria-label": resolveFormattedMessage(pdfT.pageInputAriaLabel, {
+            value: inputPage
+          })
+        }
+      ) }),
+      /* @__PURE__ */ jsx("span", { className: "opacity-60 mx-1", children: "/" }),
+      /* @__PURE__ */ jsx("span", { children: numPages })
+    ] });
+    return /* @__PURE__ */ jsxs(
+      ViewerFloatingToolbar,
+      {
+        ref: toolbarRef,
+        className: mergeClassNames(
+          pdfClassName("pagination", ""),
+          isToolbarVisible ? "opacity-100 pointer-events-auto" : "opacity-0 pointer-events-none"
+        ),
+        style: pdfStyle("pagination"),
+        children: [
+          /* @__PURE__ */ jsx(
+            FileViewerTooltip,
+            {
+              content: pdfT.previousPageTooltip,
+              disabled: props2.isFirstPage,
+              children: /* @__PURE__ */ jsx(
+                ViewerToolbarIconButton,
+                {
+                  disabled: props2.isFirstPage,
+                  onClick: previousPage,
+                  "aria-label": pdfT.previousPageAriaLabel,
+                  children: /* @__PURE__ */ jsx(ChevronLeft, { className: "h-5 w-5", "aria-hidden": true })
+                }
+              )
+            }
+          ),
+          paginationBody,
+          /* @__PURE__ */ jsx(
+            FileViewerTooltip,
+            {
+              content: pdfT.nextPageTooltip,
+              disabled: props2.isLastPage,
+              children: /* @__PURE__ */ jsx(
+                ViewerToolbarIconButton,
+                {
+                  disabled: props2.isLastPage,
+                  onClick: nextPage,
+                  "aria-label": pdfT.nextPageAriaLabel,
+                  children: /* @__PURE__ */ jsx(ChevronRight, { className: "h-5 w-5", "aria-hidden": true })
+                }
+              )
+            }
+          ),
+          /* @__PURE__ */ jsx(ViewerToolbarDivider, {}),
+          /* @__PURE__ */ jsx(
+            FileViewerTooltip,
+            {
+              content: pdfT.zoomOutTooltip,
+              disabled: zoomOutDisabled,
+              children: /* @__PURE__ */ jsx(
+                ViewerToolbarIconButton,
+                {
+                  disabled: zoomOutDisabled,
+                  onClick: handleZoomOut,
+                  "aria-label": pdfT.zoomOutAriaLabel,
+                  children: /* @__PURE__ */ jsx(ZoomOut, { className: "h-5 w-5" })
+                }
+              )
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            FileViewerTooltip,
+            {
+              content: pdfT.fitWidthTooltip,
+              disabled: fitDisabled,
+              children: /* @__PURE__ */ jsx(
+                ViewerToolbarIconButton,
+                {
+                  disabled: fitDisabled,
+                  onClick: handleZoomReset,
+                  "aria-label": pdfT.fitWidthAriaLabel,
+                  children: /* @__PURE__ */ jsx(Scan, { className: "h-5 w-5" })
+                }
+              )
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            FileViewerTooltip,
+            {
+              content: pdfT.zoomInTooltip,
+              disabled: zoomInDisabled,
+              children: /* @__PURE__ */ jsx(
+                ViewerToolbarIconButton,
+                {
+                  disabled: zoomInDisabled,
+                  onClick: handleZoomIn,
+                  "aria-label": pdfT.zoomInAriaLabel,
+                  children: /* @__PURE__ */ jsx(ZoomIn, { className: "h-5 w-5" })
+                }
+              )
+            }
+          )
+        ]
+      }
+    );
+  };
+  const pageTransitionClass = hasZoomed && pageOriginalSize.width ? "transition-[width,height] duration-200 ease-out" : "";
+  return /* @__PURE__ */ jsx(FileViewerTooltipProvider, { children: /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: pdfClassName("root", PDF_VIEWER_ROOT_DEFAULT),
+      style: pdfStyle("root"),
+      children: [
+        /* @__PURE__ */ jsxs(
+          ScrollAreaRoot,
+          {
+            className: pdfClassName("scrollArea", PDF_SCROLL_AREA_DEFAULT),
+            style: pdfStyle("scrollArea"),
+            children: [
+              /* @__PURE__ */ jsx(
+                ScrollAreaViewport,
+                {
+                  ref: containerRef,
+                  className: pdfClassName(
+                    "scrollViewport",
+                    `${PDF_SCROLL_VIEWPORT_DEFAULT} pdf-scroll-viewport`
+                  ),
+                  style: pdfStyle("scrollViewport"),
+                  children: /* @__PURE__ */ jsx("div", { className: "flex min-h-full min-w-full flex-col", children: /* @__PURE__ */ jsxs(
+                    Document,
+                    {
+                      file: url,
+                      onLoadSuccess: handleDocumentLoadSuccess,
+                      onLoadError: handleDocumentLoadError,
+                      loading: renderLoading,
+                      className: "flex w-full flex-col gap-4",
+                      children: [
+                        viewMode === "single" && zoomedRenderedDimensions.width && zoomedInstantDimensions.width && zoomedInstantDimensions.height ? /* @__PURE__ */ jsx(
+                          "div",
+                          {
+                            "data-layout-syncing": isLayoutSyncing ? "true" : void 0,
+                            className: pdfClassName(
+                              "page",
+                              PDF_PAGE_DEFAULT,
+                              pageTransitionClass
+                            ),
+                            style: {
+                              width: zoomedInstantDimensions.width,
+                              height: zoomedInstantDimensions.height,
+                              ...pdfStyle("page")
+                            },
+                            children: /* @__PURE__ */ jsx(
+                              "div",
+                              {
+                                className: pdfClassName("pageInner", PDF_PAGE_INNER_DEFAULT),
+                                style: pdfStyle("pageInner"),
+                                children: /* @__PURE__ */ jsx(
+                                  Page,
+                                  {
+                                    pageNumber,
+                                    onLoadSuccess: (page) => handlePageLoadSuccess(pageNumber, page),
+                                    renderTextLayer,
+                                    renderAnnotationLayer,
+                                    className: "flex h-full w-full shrink flex-1 items-center justify-center !bg-transparent [&_canvas]:!h-full [&_canvas]:!w-full",
+                                    renderMode: "canvas",
+                                    width: zoomedRenderedDimensions.width,
+                                    loading: null
+                                  }
+                                )
+                              }
+                            )
+                          }
+                        ) : null,
+                        viewMode === "continuous" && numPages > 0 && zoomedRenderedDimensions.width && zoomedRenderedDimensions.height && zoomedInstantDimensions.width && Array.from(new Array(numPages), (_, index) => {
+                          const p = index + 1;
+                          const isInWindow = p >= visibleRange.start - preloadAhead && p <= visibleRange.end + preloadAhead;
+                          const renderedPageHeight = renderedHeights.current.get(p) ?? zoomedRenderedDimensions.height ?? 0;
+                          const slotWidth = zoomedInstantDimensions.width ? Math.trunc(zoomedInstantDimensions.width) : void 0;
+                          const slotHeight = Math.trunc(renderedPageHeight * layoutScale);
+                          const placeholderStyle = !isInWindow && slotHeight ? {
+                            width: slotWidth,
+                            height: slotHeight,
+                            backgroundColor: "#80808040"
+                          } : {
+                            width: slotWidth,
+                            height: slotHeight
+                          };
+                          return /* @__PURE__ */ jsx(
+                            "div",
+                            {
+                              "data-layout-syncing": isLayoutSyncing ? "true" : void 0,
+                              "data-page-number": p,
+                              ref: (el) => {
+                                if (el) pageRefs.current.set(p, el);
+                                else pageRefs.current.delete(p);
+                              },
+                              className: pdfClassName(
+                                "page",
+                                PDF_PAGE_DEFAULT,
+                                pageTransitionClass
+                              ),
+                              style: { ...placeholderStyle, ...pdfStyle("page") },
+                              children: isInWindow ? /* @__PURE__ */ jsx(
+                                "div",
+                                {
+                                  className: pdfClassName(
+                                    "pageInner",
+                                    PDF_PAGE_INNER_DEFAULT
+                                  ),
+                                  style: pdfStyle("pageInner"),
+                                  children: /* @__PURE__ */ jsx(
+                                    Page,
+                                    {
+                                      pageNumber: p,
+                                      onLoadSuccess: (page) => handlePageLoadSuccess(p, page),
+                                      renderTextLayer,
+                                      renderAnnotationLayer,
+                                      className: "flex h-full w-full shrink flex-1 items-center justify-center !bg-transparent [&_canvas]:!h-full [&_canvas]:!w-full",
+                                      renderMode: "canvas",
+                                      width: zoomedRenderedDimensions.width,
+                                      loading: null
+                                    }
+                                  )
+                                }
+                              ) : null
+                            },
+                            `page_${p}`
+                          );
+                        })
+                      ]
+                    }
+                  ) })
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                ScrollAreaScrollbar,
+                {
+                  orientation: "vertical",
+                  className: pdfClassName("scrollbar", PDF_SCROLLBAR_VERTICAL_DEFAULT),
+                  style: pdfStyle("scrollbar"),
+                  children: /* @__PURE__ */ jsx(
+                    ScrollAreaThumb,
+                    {
+                      className: pdfClassName("scrollbarThumb", PDF_SCROLLBAR_THUMB_DEFAULT),
+                      style: pdfStyle("scrollbarThumb")
+                    }
+                  )
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                ScrollAreaScrollbar,
+                {
+                  orientation: "horizontal",
+                  className: pdfClassName(
+                    "scrollbar",
+                    PDF_SCROLLBAR_HORIZONTAL_DEFAULT
+                  ),
+                  style: pdfStyle("scrollbar"),
+                  children: /* @__PURE__ */ jsx(
+                    ScrollAreaThumb,
+                    {
+                      className: pdfClassName("scrollbarThumb", PDF_SCROLLBAR_THUMB_DEFAULT),
+                      style: pdfStyle("scrollbarThumb")
+                    }
+                  )
+                }
+              ),
+              /* @__PURE__ */ jsx(ScrollAreaCorner, { className: "bg-transparent" })
+            ]
+          }
+        ),
+        renderPaginationElement()
+      ]
+    }
+  ) });
+}
+var PDF_VIEWER_ROOT_DEFAULT, PDF_SCROLL_AREA_DEFAULT, PDF_SCROLL_VIEWPORT_DEFAULT, PDF_SCROLLBAR_VERTICAL_DEFAULT, PDF_SCROLLBAR_HORIZONTAL_DEFAULT, PDF_SCROLLBAR_THUMB_DEFAULT, PDF_PAGE_DEFAULT, PDF_PAGE_INNER_DEFAULT, PDF_PAGE_INPUT_DEFAULT;
+var init_PdfViewer = __esm({
+  "src/features/file-viewer/PdfViewer.tsx"() {
+    "use client";
+    init_icons();
+    init_scroll_area();
+    init_pdf_viewer();
+    init_FileViewerTooltip();
+    init_ViewerToolbar();
+    init_useAutoHide();
+    init_config();
+    init_translations();
+    init_resolve_options();
+    init_merge_slot_props();
+    PDF_VIEWER_ROOT_DEFAULT = "pdf-viewer flex flex-col items-center gap-4 w-full h-full max-h-full overflow-hidden relative";
+    PDF_SCROLL_AREA_DEFAULT = "size-full min-h-0 min-w-0";
+    PDF_SCROLL_VIEWPORT_DEFAULT = "w-full h-full rounded-[inherit] [&>div]:min-h-full";
+    PDF_SCROLLBAR_VERTICAL_DEFAULT = "flex flex-col touch-none select-none transition-colors w-4 border-l border-l-transparent p-0.5 hover:bg-black/10 z-20";
+    PDF_SCROLLBAR_HORIZONTAL_DEFAULT = "flex flex-col touch-none select-none transition-colors h-4 border-t border-t-transparent p-0.5 hover:bg-black/10 z-20";
+    PDF_SCROLLBAR_THUMB_DEFAULT = "relative shrink-0 rounded-full bg-neutral-500/50 hover:bg-neutral-500/80";
+    PDF_PAGE_DEFAULT = "relative flex shrink-0 items-center justify-center overflow-hidden m-auto";
+    PDF_PAGE_INNER_DEFAULT = "relative flex h-full w-full items-center justify-center overflow-hidden bg-white shadow-lg";
+    PDF_PAGE_INPUT_DEFAULT = "w-10 bg-transparent text-center focus:outline-none transition-colors";
+  }
+});
+
+// src/features/file-viewer/utils/zoom-utils.ts
+function calculateMultiplicativeZoom({
+  scale,
+  positionX,
+  positionY,
+  deltaY,
+  clientX,
+  clientY,
+  wrapperComponent,
+  minScale = 0.2,
+  maxScale = 8,
+  zoomFactor = 0.15
+}) {
+  const isZoomIn = deltaY < 0;
+  const factor = isZoomIn ? 1 + zoomFactor : 1 / (1 + zoomFactor);
+  const newScale = Math.max(minScale, Math.min(scale * factor, maxScale));
+  if (newScale === scale || !wrapperComponent) {
+    return { newX: positionX, newY: positionY, newScale: scale };
+  }
+  const rect = wrapperComponent.getBoundingClientRect();
+  const mx = clientX - rect.left;
+  const my = clientY - rect.top;
+  const ratio = newScale / scale;
+  const newX = mx - (mx - positionX) * ratio;
+  const newY = my - (my - positionY) * ratio;
+  return { newX, newY, newScale };
+}
+var init_zoom_utils = __esm({
+  "src/features/file-viewer/utils/zoom-utils.ts"() {
+  }
+});
+
+// src/features/file-viewer/utils/image-viewport-clamp.ts
+function roundNumber(num, decimal) {
+  return Number(num.toFixed(decimal));
+}
+function getComponentsSizes(wrapperComponent, contentComponent, newScale) {
+  const wrapperWidth = wrapperComponent.offsetWidth;
+  const wrapperHeight = wrapperComponent.offsetHeight;
+  const contentWidth = contentComponent.offsetWidth;
+  const contentHeight = contentComponent.offsetHeight;
+  const newContentWidth = contentWidth * newScale;
+  const newContentHeight = contentHeight * newScale;
+  const newDiffWidth = wrapperWidth - newContentWidth;
+  const newDiffHeight = wrapperHeight - newContentHeight;
+  return {
+    wrapperWidth,
+    wrapperHeight,
+    newContentWidth,
+    newDiffWidth,
+    newContentHeight,
+    newDiffHeight
+  };
+}
+function getBoundsFromSizes(wrapperWidth, newContentWidth, diffWidth, wrapperHeight, newContentHeight, diffHeight, centerZoomedOut) {
+  const scaleWidthFactor = wrapperWidth > newContentWidth ? diffWidth * (centerZoomedOut ? 0.5 : 1) : 0;
+  const scaleHeightFactor = wrapperHeight > newContentHeight ? diffHeight * (centerZoomedOut ? 0.5 : 1) : 0;
+  const minPositionX = wrapperWidth - newContentWidth - scaleWidthFactor;
+  const maxPositionX = scaleWidthFactor;
+  const minPositionY = wrapperHeight - newContentHeight - scaleHeightFactor;
+  const maxPositionY = scaleHeightFactor;
+  return {
+    minPositionX,
+    maxPositionX,
+    minPositionY,
+    maxPositionY
+  };
+}
+function boundLimiter(value, minBound, maxBound, isActive) {
+  if (!isActive) return roundNumber(value, 2);
+  if (value < minBound) return roundNumber(minBound, 2);
+  if (value > maxBound) return roundNumber(maxBound, 2);
+  return roundNumber(value, 2);
+}
+function getMouseBoundedPosition(positionX, positionY, bounds, limitToBounds, paddingValueX, paddingValueY, wrapperComponent) {
+  const { minPositionX, minPositionY, maxPositionX, maxPositionY } = bounds;
+  const paddingX = wrapperComponent ? paddingValueX : 0;
+  const paddingY = wrapperComponent ? paddingValueY : 0;
+  const x = boundLimiter(
+    positionX,
+    minPositionX - paddingX,
+    maxPositionX + paddingX,
+    limitToBounds
+  );
+  const y = boundLimiter(
+    positionY,
+    minPositionY - paddingY,
+    maxPositionY + paddingY,
+    limitToBounds
+  );
+  return { x, y };
+}
+function clampPanToImageBounds(wrapperComponent, contentComponent, scale, positionX, positionY, setup) {
+  const {
+    wrapperWidth,
+    wrapperHeight,
+    newContentWidth,
+    newContentHeight,
+    newDiffWidth,
+    newDiffHeight
+  } = getComponentsSizes(wrapperComponent, contentComponent, scale);
+  const bounds = getBoundsFromSizes(
+    wrapperWidth,
+    newContentWidth,
+    newDiffWidth,
+    wrapperHeight,
+    newContentHeight,
+    newDiffHeight,
+    Boolean(setup.centerZoomedOut)
+  );
+  const contentFitsCompletely = wrapperWidth >= newContentWidth && wrapperHeight >= newContentHeight;
+  if (setup.disablePadding && contentFitsCompletely && !setup.centerZoomedOut) {
+    bounds.minPositionX = 0;
+    bounds.maxPositionX = 0;
+    bounds.minPositionY = 0;
+    bounds.maxPositionY = 0;
+  }
+  const {
+    minPositionX: propMinX,
+    maxPositionX: propMaxX,
+    minPositionY: propMinY,
+    maxPositionY: propMaxY
+  } = setup;
+  if (propMinX != null) {
+    bounds.minPositionX = wrapperWidth * (1 - scale) + propMinX * scale;
+  }
+  if (propMaxX != null) {
+    bounds.maxPositionX = propMaxX * scale;
+  }
+  if (propMinY != null) {
+    bounds.minPositionY = wrapperHeight * (1 - scale) + propMinY * scale;
+  }
+  if (propMaxY != null) {
+    bounds.maxPositionY = propMaxY * scale;
+  }
+  const { x, y } = getMouseBoundedPosition(
+    positionX,
+    positionY,
+    bounds,
+    setup.limitToBounds,
+    0,
+    0,
+    wrapperComponent
+  );
+  return { positionX: x, positionY: y };
+}
+var init_image_viewport_clamp = __esm({
+  "src/features/file-viewer/utils/image-viewport-clamp.ts"() {
+  }
+});
+
+// src/features/file-viewer/ImageViewer.tsx
+var ImageViewer_exports = {};
+__export(ImageViewer_exports, {
+  default: () => ImageViewer
+});
+function ImageViewer({
+  url,
+  name,
+  language: languageProp,
+  classNames: classNamesProp,
+  styles: stylesProp
+}) {
+  const resolved = resolveImageViewerProps({
+    classNames: classNamesProp,
+    styles: stylesProp
+  });
+  const classNames = resolved.classNames;
+  const styles = resolved.styles;
+  const language = resolveOption(
+    languageProp,
+    getFileViewerDefaults().language,
+    "english"
+  );
+  const imageT = getFileViewerTranslations(language).imageViewer;
+  const autoHideDefaults = getFileViewerDefaults().autoHide;
+  const imageClassName = (key, builtIn, extra) => mergeClassNames(builtIn, classNames?.[key], extra);
+  const imageStyle = (key) => styles?.[key];
+  const [maxZoom, setMaxZoom] = useState(16);
+  const [isPanning, setIsPanning] = useState(false);
+  const [hasImageLoaded, setHasImageLoaded] = useState(false);
+  const [viewport, setViewport] = useState({
+    scale: 1,
+    positionX: 0,
+    positionY: 0
+  });
+  const minZoom = 0.5;
+  const scaleRef = useRef(null);
+  const transformRef = useRef(null);
+  const containerRef = useRef(null);
+  const toolbarRef = useRef(null);
+  const wheelClampTimerRef = useRef(null);
+  const libraryChangeUnsubscribeRef = useRef(null);
+  const isToolbarVisible = useAutoHide(toolbarRef, containerRef, {
+    proximityThreshold: autoHideDefaults?.proximityThreshold,
+    timeout: autoHideDefaults?.timeout,
+    activityDeps: [viewport.scale]
+  });
+  const updateScaleText = useCallback((scale) => {
+    if (scaleRef.current) {
+      scaleRef.current.innerText = `${Math.round(scale * 100)}%`;
+    }
+  }, []);
+  const syncViewportFromLibrary = useCallback(
+    (libraryRef) => {
+      const { scale, positionX, positionY } = libraryRef.instance.state;
+      setViewport({ scale, positionX, positionY });
+      updateScaleText(scale);
+    },
+    [updateScaleText]
+  );
+  const handleLibraryInit = useCallback(
+    (libraryRef) => {
+      libraryChangeUnsubscribeRef.current?.();
+      libraryChangeUnsubscribeRef.current = null;
+      syncViewportFromLibrary(libraryRef);
+      libraryChangeUnsubscribeRef.current = libraryRef.instance.onChange(
+        (nextRef) => {
+          syncViewportFromLibrary(nextRef);
+        }
+      );
+    },
+    [syncViewportFromLibrary]
+  );
+  const scheduleWheelViewportClamp = useCallback(() => {
+    if (wheelClampTimerRef.current !== null) {
+      clearTimeout(wheelClampTimerRef.current);
+    }
+    wheelClampTimerRef.current = window.setTimeout(() => {
+      wheelClampTimerRef.current = null;
+      const ref = transformRef.current;
+      if (!ref) return;
+      const { instance } = ref;
+      const { scale, positionX, positionY } = instance.state;
+      const wrapper = instance.wrapperComponent;
+      const content = instance.contentComponent;
+      if (!wrapper || !content) return;
+      const setup = instance.setup;
+      const clamped = clampPanToImageBounds(
+        wrapper,
+        content,
+        scale,
+        positionX,
+        positionY,
+        {
+          centerZoomedOut: Boolean(setup.centerZoomedOut),
+          disablePadding: Boolean(setup.disablePadding),
+          minPositionX: setup.minPositionX ?? null,
+          maxPositionX: setup.maxPositionX ?? null,
+          minPositionY: setup.minPositionY ?? null,
+          maxPositionY: setup.maxPositionY ?? null,
+          limitToBounds: Boolean(setup.limitToBounds)
+        }
+      );
+      if (Math.abs(clamped.positionX - positionX) > 0.01 || Math.abs(clamped.positionY - positionY) > 0.01) {
+        ref.setTransform(
+          clamped.positionX,
+          clamped.positionY,
+          scale,
+          WHEEL_CLAMP_ANIMATION_MS,
+          "easeOut"
+        );
+      }
+    }, WHEEL_VIEWPORT_CLAMP_DEBOUNCE_MS);
+  }, []);
+  useEffect(() => {
+    return () => {
+      if (wheelClampTimerRef.current !== null) {
+        clearTimeout(wheelClampTimerRef.current);
+      }
+      libraryChangeUnsubscribeRef.current?.();
+      libraryChangeUnsubscribeRef.current = null;
+    };
+  }, []);
+  useEffect(() => {
+    setHasImageLoaded(false);
+  }, [url]);
+  const handleImageLoad = (event) => {
+    const img = event.currentTarget;
+    const naturalWidth = img.naturalWidth;
+    const currentWidth = img.clientWidth;
+    if (naturalWidth && currentWidth) {
+      const nativeScale = naturalWidth / currentWidth;
+      const calculatedMax = Math.max(4, Math.min(16, nativeScale * 2));
+      setMaxZoom(calculatedMax);
+    }
+    setHasImageLoaded(true);
+  };
+  const handleImageError = () => {
+    setHasImageLoaded(true);
+  };
+  const applyWheelZoom = useCallback(
+    (event) => {
+      if (!hasImageLoaded) return;
+      const ref = transformRef.current;
+      if (!ref) return;
+      event.preventDefault();
+      event.stopPropagation();
+      const { scale, positionX, positionY } = ref.state;
+      const { newX, newY, newScale } = calculateMultiplicativeZoom({
+        scale,
+        positionX,
+        positionY,
+        deltaY: event.deltaY,
+        clientX: event.clientX,
+        clientY: event.clientY,
+        wrapperComponent: ref.instance.wrapperComponent,
+        minScale: minZoom,
+        maxScale: maxZoom
+      });
+      if (newScale !== scale) {
+        ref.setTransform(newX, newY, newScale, 0);
+        scheduleWheelViewportClamp();
+      }
+    },
+    [hasImageLoaded, maxZoom, scheduleWheelViewportClamp]
+  );
+  useEffect(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const handleWheel = (event) => {
+      if (!container.contains(event.target)) return;
+      applyWheelZoom(event);
+    };
+    container.addEventListener("wheel", handleWheel, { passive: false });
+    return () => container.removeEventListener("wheel", handleWheel);
+  }, [applyWheelZoom, hasImageLoaded]);
+  const zoomOutDisabled = viewport.scale <= minZoom + SCALE_EPSILON;
+  const zoomInDisabled = viewport.scale >= maxZoom - SCALE_EPSILON;
+  const nearDefaultPan = Math.abs(viewport.positionX) < 12 && Math.abs(viewport.positionY) < 12;
+  const fitDisabled = Math.abs(viewport.scale - 1) < FIT_AT_ONE_EPSILON && nearDefaultPan;
+  const wrapperCursorClass = isPanning ? "cursor-move" : "";
+  return /* @__PURE__ */ jsx(FileViewerTooltipProvider, { children: /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref: containerRef,
+      className: imageClassName("root", IMAGE_ROOT_DEFAULT),
+      style: imageStyle("root"),
+      children: [
+        !hasImageLoaded ? /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: imageClassName("loader", IMAGE_LOADER_OVERLAY_DEFAULT),
+            style: imageStyle("loader"),
+            "aria-busy": true,
+            "aria-live": "polite",
+            children: /* @__PURE__ */ jsx(LoaderCircle, { className: IMAGE_LOADER_ICON_DEFAULT, "aria-hidden": true })
+          }
+        ) : null,
+        /* @__PURE__ */ jsx(
+          TransformWrapper,
+          {
+            ref: transformRef,
+            initialScale: 1,
+            minScale: minZoom,
+            maxScale: maxZoom,
+            centerOnInit: true,
+            limitToBounds: true,
+            wheel: { disabled: true },
+            onInit: handleLibraryInit,
+            onPanningStart: () => setIsPanning(true),
+            onPanningStop: () => setIsPanning(false),
+            children: ({ zoomIn, zoomOut, resetTransform }) => /* @__PURE__ */ jsxs(Fragment, { children: [
+              /* @__PURE__ */ jsx(
+                TransformComponent,
+                {
+                  wrapperClass: `!size-full ${wrapperCursorClass}`,
+                  contentClass: "!size-full flex items-center justify-center",
+                  children: /* @__PURE__ */ jsx(
+                    "img",
+                    {
+                      src: url,
+                      alt: name,
+                      onLoad: handleImageLoad,
+                      onError: handleImageError,
+                      className: imageClassName("image", IMAGE_IMG_DEFAULT),
+                      style: imageStyle("image")
+                    }
+                  )
+                }
+              ),
+              /* @__PURE__ */ jsxs(
+                ViewerFloatingToolbar,
+                {
+                  ref: toolbarRef,
+                  className: mergeClassNames(
+                    imageClassName("toolbar", ""),
+                    isToolbarVisible ? "opacity-100 pointer-events-auto" : "opacity-0 pointer-events-none"
+                  ),
+                  style: imageStyle("toolbar"),
+                  children: [
+                    /* @__PURE__ */ jsx(
+                      "span",
+                      {
+                        ref: scaleRef,
+                        className: "w-12 text-center text-sm font-medium text-white/90",
+                        children: "100%"
+                      }
+                    ),
+                    /* @__PURE__ */ jsx(ViewerToolbarDivider, {}),
+                    /* @__PURE__ */ jsx(
+                      FileViewerTooltip,
+                      {
+                        content: imageT.zoomOutTooltip,
+                        disabled: zoomOutDisabled,
+                        children: /* @__PURE__ */ jsx(
+                          ViewerToolbarIconButton,
+                          {
+                            disabled: zoomOutDisabled,
+                            onClick: () => zoomOut(),
+                            "aria-label": imageT.zoomOutAriaLabel,
+                            children: /* @__PURE__ */ jsx(ZoomOut, { className: "size-5" })
+                          }
+                        )
+                      }
+                    ),
+                    /* @__PURE__ */ jsx(
+                      FileViewerTooltip,
+                      {
+                        content: imageT.fitScreenTooltip,
+                        disabled: fitDisabled,
+                        children: /* @__PURE__ */ jsx(
+                          ViewerToolbarIconButton,
+                          {
+                            disabled: fitDisabled,
+                            onClick: () => {
+                              resetTransform();
+                              updateScaleText(1);
+                            },
+                            "aria-label": imageT.fitScreenAriaLabel,
+                            children: /* @__PURE__ */ jsx(Scan, { className: "size-5" })
+                          }
+                        )
+                      }
+                    ),
+                    /* @__PURE__ */ jsx(
+                      FileViewerTooltip,
+                      {
+                        content: imageT.zoomInTooltip,
+                        disabled: zoomInDisabled,
+                        children: /* @__PURE__ */ jsx(
+                          ViewerToolbarIconButton,
+                          {
+                            disabled: zoomInDisabled,
+                            onClick: () => zoomIn(),
+                            "aria-label": imageT.zoomInAriaLabel,
+                            children: /* @__PURE__ */ jsx(ZoomIn, { className: "size-5" })
+                          }
+                        )
+                      }
+                    )
+                  ]
+                }
+              )
+            ] })
+          },
+          url
+        )
+      ]
+    }
+  ) });
+}
+var IMAGE_ROOT_DEFAULT, IMAGE_LOADER_OVERLAY_DEFAULT, IMAGE_LOADER_ICON_DEFAULT, IMAGE_IMG_DEFAULT, SCALE_EPSILON, FIT_AT_ONE_EPSILON, WHEEL_VIEWPORT_CLAMP_DEBOUNCE_MS, WHEEL_CLAMP_ANIMATION_MS;
+var init_ImageViewer = __esm({
+  "src/features/file-viewer/ImageViewer.tsx"() {
+    "use client";
+    init_icons();
+    init_ViewerToolbar();
+    init_config();
+    init_useAutoHide();
+    init_FileViewerTooltip();
+    init_zoom_utils();
+    init_image_viewport_clamp();
+    init_translations();
+    init_merge_slot_props();
+    init_resolve_options();
+    IMAGE_ROOT_DEFAULT = "relative flex size-full items-center justify-center overflow-hidden";
+    IMAGE_LOADER_OVERLAY_DEFAULT = "absolute inset-0 z-30 flex items-center justify-center bg-neutral-950/40";
+    IMAGE_LOADER_ICON_DEFAULT = "size-10 animate-spin text-white";
+    IMAGE_IMG_DEFAULT = "max-h-[calc(100dvh-10rem)] max-w-full shadow";
+    SCALE_EPSILON = 0.012;
+    FIT_AT_ONE_EPSILON = 0.018;
+    WHEEL_VIEWPORT_CLAMP_DEBOUNCE_MS = 500;
+    WHEEL_CLAMP_ANIMATION_MS = 320;
+  }
+});
+var FOCUSABLE_SELECTOR = 'a[href], button:not([disabled]), textarea:not([disabled]), input:not([disabled]), select:not([disabled]), [tabindex]:not([tabindex="-1"])';
+function useFocusTrap(containerRef, active) {
+  useEffect(() => {
+    if (!active) return;
+    const container = containerRef.current;
+    if (!container) return;
+    const focusable = container.querySelectorAll(FOCUSABLE_SELECTOR);
+    const first = focusable[0];
+    const last = focusable[focusable.length - 1];
+    first?.focus();
+    const handleKeyDown = (event) => {
+      if (event.key !== "Tab" || focusable.length === 0) return;
+      if (event.shiftKey) {
+        if (document.activeElement === first) {
+          event.preventDefault();
+          last?.focus();
+        }
+        return;
+      }
+      if (document.activeElement === last) {
+        event.preventDefault();
+        first?.focus();
+      }
+    };
+    document.addEventListener("keydown", handleKeyDown);
+    return () => document.removeEventListener("keydown", handleKeyDown);
+  }, [active, containerRef]);
+}
+
+// src/features/file-viewer/primitives/dialog.tsx
+init_as_child();
+var DialogContext = createContext(null);
+function useDialogContext(component) {
+  const context = useContext(DialogContext);
+  if (!context) {
+    throw new Error(`${component} must be used within Dialog.Root`);
+  }
+  return context;
+}
+function Root({
+  open,
+  onOpenChange,
+  children
+}) {
+  const titleId = useId();
+  return /* @__PURE__ */ jsx(DialogContext.Provider, { value: { open, onOpenChange, titleId }, children });
+}
+function Portal({ children }) {
+  const { open } = useDialogContext("Dialog.Portal");
+  if (!open || typeof document === "undefined") {
+    return null;
+  }
+  return createPortal(children, document.body);
+}
+function Content({
+  children,
+  className,
+  style,
+  "aria-describedby": ariaDescribedBy,
+  ...rest
+}) {
+  const { open, onOpenChange, titleId } = useDialogContext("Dialog.Content");
+  const contentRef = useRef(null);
+  useFocusTrap(contentRef, open);
+  useEffect(() => {
+    if (!open) {
+      return;
+    }
+    const previousOverflow = document.body.style.overflow;
+    document.body.style.overflow = "hidden";
+    return () => {
+      document.body.style.overflow = previousOverflow;
+    };
+  }, [open]);
+  useEffect(() => {
+    if (!open) {
+      return;
+    }
+    const handleKeyDown = (event) => {
+      if (event.key === "Escape") {
+        onOpenChange(false);
+      }
+    };
+    document.addEventListener("keydown", handleKeyDown);
+    return () => {
+      document.removeEventListener("keydown", handleKeyDown);
+    };
+  }, [open, onOpenChange]);
+  if (!open) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref: contentRef,
+      role: "dialog",
+      "aria-modal": "true",
+      "aria-labelledby": titleId,
+      "aria-describedby": ariaDescribedBy,
+      "data-visible": open ? "true" : "false",
+      className,
+      style,
+      ...rest,
+      children
+    }
+  );
+}
+function Close({
+  asChild,
+  children
+}) {
+  const { onOpenChange } = useDialogContext("Dialog.Close");
+  const handleClick = (event) => {
+    children.props.onClick?.(event);
+    onOpenChange(false);
+  };
+  if (asChild) {
+    return renderAsChild(true, children, { onClick: handleClick });
+  }
+  return /* @__PURE__ */ jsx("button", { type: "button", onClick: handleClick, children });
+}
+function Title({
+  asChild,
+  children
+}) {
+  const { titleId } = useDialogContext("Dialog.Title");
+  if (asChild && isValidElement(children)) {
+    return renderAsChild(true, children, { id: titleId });
+  }
+  return /* @__PURE__ */ jsx("p", { id: titleId, children });
+}
+
+// src/features/file-viewer/FileViewer.tsx
+init_icons();
+init_FileViewerTooltip();
+init_config();
+init_translations();
+
+// src/features/file-viewer/utils/file-actions.ts
+function printPdfFromUrl(url) {
+  const iframe = document.createElement("iframe");
+  iframe.setAttribute(
+    "style",
+    "position:fixed;right:0;bottom:0;width:0;height:0;border:0;visibility:hidden"
+  );
+  iframe.setAttribute("aria-hidden", "true");
+  iframe.src = url;
+  const removeIframe = () => {
+    iframe.remove();
+  };
+  const onLoad = () => {
+    try {
+      iframe.contentWindow?.focus();
+      iframe.contentWindow?.print();
+    } finally {
+      window.setTimeout(removeIframe, 500);
+    }
+  };
+  iframe.addEventListener("load", onLoad, { once: true });
+  iframe.addEventListener("error", removeIframe, { once: true });
+  document.body.appendChild(iframe);
+}
+async function downloadFileFromUrl(url, filename) {
+  try {
+    const response = await fetch(url);
+    const blob = await response.blob();
+    const objectUrl = URL.createObjectURL(blob);
+    const anchor = document.createElement("a");
+    anchor.href = objectUrl;
+    anchor.download = filename;
+    anchor.rel = "noopener";
+    document.body.appendChild(anchor);
+    anchor.click();
+    anchor.remove();
+    window.setTimeout(() => URL.revokeObjectURL(objectUrl), 2e3);
+  } catch {
+    const anchor = document.createElement("a");
+    anchor.href = url;
+    anchor.download = filename;
+    anchor.target = "_blank";
+    anchor.rel = "noopener noreferrer";
+    document.body.appendChild(anchor);
+    anchor.click();
+    anchor.remove();
+  }
+}
+
+// src/features/file-viewer/FileViewer.tsx
+init_resolve_options();
+init_merge_slot_props();
+var LazyPdfViewer = lazy(() => Promise.resolve().then(() => (init_PdfViewer(), PdfViewer_exports)));
+var LazyImageViewer = lazy(() => Promise.resolve().then(() => (init_ImageViewer(), ImageViewer_exports)));
+var FILE_VIEWER_DIALOG_BACKDROP_DEFAULT = "fixed inset-0 z-[100] cursor-default border-0 bg-black/80 p-0 data-[visible=true]:animate-in data-[visible=false]:animate-out data-[visible=false]:fade-out-0 data-[visible=true]:fade-in-0";
+var FILE_VIEWER_DIALOG_CONTENT_DEFAULT = "fixed inset-0 z-[101] flex h-full w-full min-h-0 cursor-default flex-col border-none bg-transparent p-0 shadow-none outline-none pointer-events-none duration-200 data-[visible=true]:animate-in data-[visible=false]:animate-out data-[visible=false]:fade-out-0 data-[visible=true]:fade-in-0 focus:outline-none";
+var FILE_VIEWER_DIALOG_PANEL_DEFAULT = "pointer-events-auto flex h-full w-full min-h-0 flex-col overflow-hidden rounded-none border-0 bg-neutral-800/95 shadow-none";
+var FILE_VIEWER_ROOT_DEFAULT = "flex min-h-0 flex-1 flex-col overflow-hidden";
+var FILE_VIEWER_HEADER_DEFAULT = "flex w-full shrink-0 justify-between gap-2 rounded-t-lg p-4 font-medium text-white";
+var FILE_VIEWER_HEADER_TITLE_WRAP_DEFAULT = "flex items-center gap-2";
+var FILE_VIEWER_CLOSE_BUTTON_DEFAULT = "cursor-pointer rounded-sm opacity-70 transition-opacity hover:opacity-100 focus:outline-none focus-visible:opacity-100 focus-visible:ring-1 focus-visible:ring-white focus-visible:ring-offset-0 disabled:pointer-events-none";
+var FILE_VIEWER_TITLE_MODAL_DEFAULT = "truncate";
+var FILE_VIEWER_TITLE_INLINE_DEFAULT = "truncate font-semibold";
+var FILE_VIEWER_HEADER_ACTIONS_DEFAULT = "flex gap-3";
+var FILE_VIEWER_ACTION_BUTTON_DEFAULT = "cursor-pointer rounded-sm opacity-70 transition-opacity hover:opacity-100 focus:outline-none focus-visible:opacity-100 focus-visible:ring-1 focus-visible:ring-white focus-visible:ring-offset-0";
+var FILE_VIEWER_ACTION_BUTTON_DOWNLOAD_DEFAULT = "cursor-pointer rounded-sm opacity-70 transition-opacity hover:opacity-100 focus:outline-none focus-visible:opacity-100 focus-visible:ring-1 focus-visible:ring-white focus-visible:ring-offset-0 disabled:pointer-events-none disabled:opacity-50";
+var FILE_VIEWER_VIEWER_DEFAULT = "flex min-h-0 w-full flex-1 items-center justify-center overflow-hidden text-white";
+var FILE_VIEWER_LOADER_DEFAULT = "size-10 animate-spin";
+function mergeFileViewerSlotClassName(builtIn, globalValue, instanceValue) {
+  return mergeClassNames(builtIn, globalValue, instanceValue);
+}
+function FileViewer({
+  mode: modeProp,
+  open,
+  onOpenChange,
+  name,
+  extension,
+  url,
+  isLoading,
+  onDownload,
+  pdfViewerProps,
+  renderUnsupported,
+  language: languageProp,
+  hideCloseButton: hideCloseButtonProp,
+  showOpenInModalButton: showOpenInModalButtonProp,
+  onOpenInModal,
+  classNames,
+  styles,
+  dialogClassNames,
+  dialogStyles
+}) {
+  const globalFileViewer = getFileViewerDefaults().fileViewer;
+  const mode = resolveOption(modeProp, globalFileViewer?.mode, "inline");
+  const language = resolveOption(
+    languageProp,
+    getFileViewerDefaults().language,
+    "english"
+  );
+  const contentRef = useRef(null);
+  const printImage = useReactToPrint({ contentRef });
+  const t = getFileViewerTranslations(language);
+  const ext = extension.toLowerCase();
+  const isPdf = ext === "pdf";
+  const isImage = ["jpg", "png", "jpeg"].includes(ext);
+  const supportedForPreview = isPdf || isImage;
+  const [isMounted, setIsMounted] = useState(false);
+  const [isDownloading, setIsDownloading] = useState(false);
+  const [isModalPreviewOpen, setIsModalPreviewOpen] = useState(false);
+  const showOpenInModalButton = mode === "inline" && resolveOption(
+    showOpenInModalButtonProp,
+    globalFileViewer?.showOpenInModalButton,
+    true
+  );
+  const mergedPdfViewerProps = resolvePdfViewerProps(pdfViewerProps);
+  const mergedImageViewerProps = resolveImageViewerProps();
+  useEffect(() => {
+    setIsMounted(true);
+  }, []);
+  useEffect(() => {
+    setIsDownloading(false);
+  }, [open, url]);
+  useEffect(() => {
+    if (!open) {
+      setIsModalPreviewOpen(false);
+    }
+  }, [open]);
+  const slotClassName = (key, builtIn) => mergeFileViewerSlotClassName(
+    builtIn,
+    globalFileViewer?.classNames?.[key],
+    classNames?.[key]
+  );
+  const slotStyle = (key) => mergeStyles(globalFileViewer?.styles?.[key], styles?.[key]);
+  const backdropClasses = mergeFileViewerSlotClassName(
+    FILE_VIEWER_DIALOG_BACKDROP_DEFAULT,
+    globalFileViewer?.dialogClassNames?.backdrop,
+    dialogClassNames?.backdrop
+  );
+  const contentClasses = mergeFileViewerSlotClassName(
+    FILE_VIEWER_DIALOG_CONTENT_DEFAULT,
+    globalFileViewer?.dialogClassNames?.content,
+    dialogClassNames?.content
+  );
+  const panelClasses = mergeFileViewerSlotClassName(
+    FILE_VIEWER_DIALOG_PANEL_DEFAULT,
+    globalFileViewer?.dialogClassNames?.panel,
+    dialogClassNames?.panel
+  );
+  const backdropStyle = mergeStyles(
+    globalFileViewer?.dialogStyles?.backdrop,
+    dialogStyles?.backdrop
+  );
+  const contentStyle = mergeStyles(
+    globalFileViewer?.dialogStyles?.content,
+    dialogStyles?.content
+  );
+  const panelStyle = mergeStyles(
+    globalFileViewer?.dialogStyles?.panel,
+    dialogStyles?.panel
+  );
+  const renderPdf = () => {
+    if (!isMounted) return null;
+    return /* @__PURE__ */ jsx(
+      Suspense,
+      {
+        fallback: /* @__PURE__ */ jsx(
+          LoaderCircle,
+          {
+            className: slotClassName("loader", "animate-spin size-10 text-white"),
+            style: slotStyle("loader")
+          }
+        ),
+        children: /* @__PURE__ */ jsx(LazyPdfViewer, { url, ...mergedPdfViewerProps, language })
+      }
+    );
+  };
+  const renderImage = () => {
+    if (!isMounted) return null;
+    return /* @__PURE__ */ jsx(
+      Suspense,
+      {
+        fallback: /* @__PURE__ */ jsx(
+          LoaderCircle,
+          {
+            className: slotClassName("loader", "animate-spin size-10 text-white"),
+            style: slotStyle("loader")
+          }
+        ),
+        children: /* @__PURE__ */ jsx(
+          LazyImageViewer,
+          {
+            url,
+            name,
+            language,
+            ...mergedImageViewerProps
+          }
+        )
+      }
+    );
+  };
+  const handlePrint = () => {
+    if (!url) return;
+    if (isPdf) {
+      printPdfFromUrl(url);
+    } else {
+      printImage();
+    }
+  };
+  const handleDownload = async () => {
+    if (!url || isDownloading) return;
+    setIsDownloading(true);
+    try {
+      if (onDownload) {
+        await Promise.resolve(onDownload());
+      } else {
+        await downloadFileFromUrl(url, name);
+      }
+    } finally {
+      setIsDownloading(false);
+    }
+  };
+  const handleOpenInModal = () => {
+    if (onOpenInModal) {
+      onOpenInModal();
+      return;
+    }
+    setIsModalPreviewOpen(true);
+  };
+  const renderCloseButton = (activeMode) => {
+    const hideClose = resolveHideCloseButton(
+      hideCloseButtonProp,
+      globalFileViewer?.hideCloseButton,
+      activeMode
+    );
+    if (hideClose) {
+      return null;
+    }
+    if (activeMode === "modal") {
+      return /* @__PURE__ */ jsx(Close, { asChild: true, children: /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          "aria-label": t.fileViewer.closeAriaLabel,
+          className: slotClassName("closeButton", FILE_VIEWER_CLOSE_BUTTON_DEFAULT),
+          style: slotStyle("closeButton"),
+          children: /* @__PURE__ */ jsx(X, { className: "size-7", "aria-hidden": true })
+        }
+      ) });
+    }
+    return /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        onClick: () => onOpenChange(false),
+        "aria-label": t.fileViewer.closeAriaLabel,
+        className: slotClassName("closeButton", FILE_VIEWER_CLOSE_BUTTON_DEFAULT),
+        style: slotStyle("closeButton"),
+        children: /* @__PURE__ */ jsx(X, { className: "size-7", "aria-hidden": true })
+      }
+    );
+  };
+  const renderPanelContent = (activeMode) => {
+    const closeButton = renderCloseButton(activeMode);
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: slotClassName("root", FILE_VIEWER_ROOT_DEFAULT),
+        style: slotStyle("root"),
+        children: [
+          /* @__PURE__ */ jsxs(
+            "div",
+            {
+              className: slotClassName("header", FILE_VIEWER_HEADER_DEFAULT),
+              style: slotStyle("header"),
+              children: [
+                /* @__PURE__ */ jsxs("span", { className: FILE_VIEWER_HEADER_TITLE_WRAP_DEFAULT, children: [
+                  closeButton,
+                  activeMode === "modal" ? /* @__PURE__ */ jsx(Title, { asChild: true, children: /* @__PURE__ */ jsx(
+                    "p",
+                    {
+                      className: slotClassName(
+                        "headerTitle",
+                        FILE_VIEWER_TITLE_MODAL_DEFAULT
+                      ),
+                      style: slotStyle("headerTitle"),
+                      children: name
+                    }
+                  ) }) : /* @__PURE__ */ jsx(
+                    "p",
+                    {
+                      className: slotClassName(
+                        "headerTitle",
+                        FILE_VIEWER_TITLE_INLINE_DEFAULT
+                      ),
+                      style: slotStyle("headerTitle"),
+                      children: name
+                    }
+                  )
+                ] }),
+                url && !isLoading && supportedForPreview ? /* @__PURE__ */ jsxs(
+                  "span",
+                  {
+                    className: slotClassName(
+                      "headerActions",
+                      FILE_VIEWER_HEADER_ACTIONS_DEFAULT
+                    ),
+                    style: slotStyle("headerActions"),
+                    children: [
+                      showOpenInModalButton && activeMode === "inline" ? /* @__PURE__ */ jsx(FileViewerTooltip, { content: t.fileViewer.openInModalTooltip, children: /* @__PURE__ */ jsx(
+                        "button",
+                        {
+                          type: "button",
+                          onClick: handleOpenInModal,
+                          className: slotClassName(
+                            "openInModalButton",
+                            FILE_VIEWER_ACTION_BUTTON_DEFAULT
+                          ),
+                          style: slotStyle("openInModalButton"),
+                          "aria-label": t.fileViewer.openInModalAriaLabel,
+                          children: /* @__PURE__ */ jsx(Maximize2, { className: "size-6", "aria-hidden": true })
+                        }
+                      ) }) : null,
+                      /* @__PURE__ */ jsx(FileViewerTooltip, { content: t.fileViewer.printTooltip, children: /* @__PURE__ */ jsx(
+                        "button",
+                        {
+                          type: "button",
+                          onClick: handlePrint,
+                          className: slotClassName(
+                            "printButton",
+                            FILE_VIEWER_ACTION_BUTTON_DEFAULT
+                          ),
+                          style: slotStyle("printButton"),
+                          "aria-label": t.fileViewer.printAriaLabel,
+                          children: /* @__PURE__ */ jsx(Printer, { className: "size-6", "aria-hidden": true })
+                        }
+                      ) }),
+                      /* @__PURE__ */ jsx(
+                        FileViewerTooltip,
+                        {
+                          content: isDownloading ? t.fileViewer.downloadInProgressTooltip : t.fileViewer.downloadTooltip,
+                          children: /* @__PURE__ */ jsx(
+                            "button",
+                            {
+                              type: "button",
+                              disabled: isDownloading,
+                              onClick: () => {
+                                void handleDownload();
+                              },
+                              className: slotClassName(
+                                "downloadButton",
+                                FILE_VIEWER_ACTION_BUTTON_DOWNLOAD_DEFAULT
+                              ),
+                              style: slotStyle("downloadButton"),
+                              "aria-busy": isDownloading,
+                              "aria-label": isDownloading ? t.fileViewer.downloadInProgressAriaLabel : t.fileViewer.downloadAriaLabel,
+                              children: isDownloading ? /* @__PURE__ */ jsx(LoaderCircle, { className: "size-6 animate-spin", "aria-hidden": true }) : /* @__PURE__ */ jsx(Download, { className: "size-6", "aria-hidden": true })
+                            }
+                          )
+                        }
+                      )
+                    ]
+                  }
+                ) : null
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "div",
+            {
+              className: slotClassName("viewer", FILE_VIEWER_VIEWER_DEFAULT),
+              style: slotStyle("viewer"),
+              children: !url || isLoading ? /* @__PURE__ */ jsx(
+                LoaderCircle,
+                {
+                  className: slotClassName("loader", FILE_VIEWER_LOADER_DEFAULT),
+                  style: slotStyle("loader")
+                }
+              ) : isImage ? renderImage() : isPdf ? renderPdf() : renderUnsupported || /* @__PURE__ */ jsx(
+                "p",
+                {
+                  className: slotClassName("unsupported", ""),
+                  style: slotStyle("unsupported"),
+                  children: resolveFormattedMessage(t.fileViewer.unsupportedFileType, {
+                    extension
+                  })
+                }
+              )
+            }
+          )
+        ]
+      }
+    );
+  };
+  const renderModalShell = (modalOpen, onModalOpenChange, content) => /* @__PURE__ */ jsx(Root, { open: modalOpen, onOpenChange: onModalOpenChange, children: /* @__PURE__ */ jsxs(Portal, { children: [
+    /* @__PURE__ */ jsx(Close, { asChild: true, children: /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        tabIndex: -1,
+        "data-visible": modalOpen,
+        className: backdropClasses,
+        style: backdropStyle,
+        "aria-hidden": true
+      }
+    ) }),
+    /* @__PURE__ */ jsx(
+      Content,
+      {
+        "aria-describedby": void 0,
+        className: contentClasses,
+        style: contentStyle,
+        children: /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: panelClasses,
+            style: panelStyle,
+            onClick: (event) => event.stopPropagation(),
+            children: content
+          }
+        )
+      }
+    )
+  ] }) });
+  const printOnlyNode = isImage && url ? /* @__PURE__ */ jsx("div", { className: "hidden", children: /* @__PURE__ */ jsx("div", { ref: contentRef, children: /* @__PURE__ */ jsx("img", { src: url, className: "max-h-[105dvh]", alt: name }) }) }) : null;
+  if (mode === "inline") {
+    if (!open) return null;
+    return /* @__PURE__ */ jsxs(FileViewerTooltipProvider, { children: [
+      /* @__PURE__ */ jsx("div", { className: panelClasses, style: panelStyle, children: renderPanelContent("inline") }),
+      isModalPreviewOpen ? renderModalShell(
+        isModalPreviewOpen,
+        setIsModalPreviewOpen,
+        renderPanelContent("modal")
+      ) : null,
+      printOnlyNode
+    ] });
+  }
+  return /* @__PURE__ */ jsxs(FileViewerTooltipProvider, { children: [
+    renderModalShell(open, onOpenChange, renderPanelContent("modal")),
+    printOnlyNode
+  ] });
+}
+
+// src/features/file-viewer/index.ts
+init_PdfViewer();
+init_ImageViewer();
+init_FileViewerTooltip();
+var configuredWorkerSrc;
+function getFileViewerPdfWorkerSrc() {
+  return `https://unpkg.com/pdfjs-dist@${pdfjs.version}/build/pdf.worker.min.mjs`;
+}
+var getFileViewerPdfWorkerCdnUrl = getFileViewerPdfWorkerSrc;
+function isFileViewerPdfWorkerConfigured() {
+  return configuredWorkerSrc !== void 0;
+}
+function configureFileViewerPdfWorker(options = {}) {
+  const workerSrc = options.workerSrc ?? getFileViewerPdfWorkerSrc();
+  pdfjs.GlobalWorkerOptions.workerSrc = workerSrc;
+  configuredWorkerSrc = workerSrc;
+}
+
+// src/features/file-viewer/index.ts
+init_config();
+init_translations();
+
+export { FileViewer, FileViewerTooltip, FileViewerTooltipProvider, ImageViewer, PdfViewer, configureFileViewerPdfWorker, defaultFileViewerTranslations, fileViewerTranslationsByLanguage, getFileViewerDefaults, getFileViewerPdfWorkerCdnUrl, getFileViewerPdfWorkerSrc, getFileViewerTranslations, isFileViewerPdfWorkerConfigured, resetFileViewerDefaults, resolveFormattedMessage, resolveImageViewerProps, resolvePdfViewerProps, setFileViewerDefaults };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map