@matangot/react-pdf-viewer 0.1.0

package/dist/index.js

@@ -0,0 +1,2148 @@
+// src/components/Root.tsx
+import { useRef as useRef3 } from "react";
+
+// src/context.tsx
+import {
+  createContext,
+  useContext,
+  useState as useState2,
+  useCallback,
+  useMemo,
+  useRef as useRef2
+} from "react";
+
+// src/hooks/use-pdf-document.ts
+import { useState, useEffect, useRef } from "react";
+import { getDocument } from "pdfjs-dist";
+function usePdfDocument(src, onDocumentLoad) {
+  const [document, setDocument] = useState(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const prevSrcRef = useRef(null);
+  const objectUrlRef = useRef(null);
+  useEffect(() => {
+    if (src === prevSrcRef.current) return;
+    prevSrcRef.current = src;
+    if (objectUrlRef.current) {
+      URL.revokeObjectURL(objectUrlRef.current);
+      objectUrlRef.current = null;
+    }
+    let cancelled = false;
+    setIsLoading(true);
+    setError(null);
+    const init = getDocumentInit(src);
+    if (src instanceof File) {
+      objectUrlRef.current = init.url;
+    }
+    const loadingTask = getDocument(init);
+    loadingTask.promise.then(async (doc) => {
+      if (cancelled) {
+        doc.destroy();
+        return;
+      }
+      setDocument(doc);
+      setIsLoading(false);
+      const metadata = await doc.getMetadata();
+      const info = metadata.info;
+      onDocumentLoad?.({
+        numPages: doc.numPages,
+        title: info?.Title,
+        author: info?.Author
+      });
+    }).catch((err) => {
+      if (cancelled) return;
+      setError(err instanceof Error ? err : new Error(String(err)));
+      setIsLoading(false);
+    });
+    return () => {
+      cancelled = true;
+      if (objectUrlRef.current) {
+        URL.revokeObjectURL(objectUrlRef.current);
+        objectUrlRef.current = null;
+      }
+    };
+  }, [src]);
+  return { document, isLoading, error };
+}
+function getDocumentInit(src) {
+  if (typeof src === "string") {
+    return { url: src };
+  }
+  if (src instanceof File) {
+    return { url: URL.createObjectURL(src) };
+  }
+  return { data: src };
+}
+
+// src/constants.ts
+var DEFAULT_ZOOM = 1;
+var MIN_ZOOM = 0.25;
+var MAX_ZOOM = 4;
+var ZOOM_STEP = 0.25;
+var VIRTUALIZATION_BUFFER = 2;
+var THUMBNAIL_SCALE = 0.2;
+
+// src/context.tsx
+import { jsx } from "react/jsx-runtime";
+var PdfViewerContext = createContext(null);
+function usePdfViewerContext() {
+  const ctx = useContext(PdfViewerContext);
+  if (!ctx) {
+    throw new Error(
+      "usePdfViewerContext must be used within a PdfViewerProvider"
+    );
+  }
+  return ctx;
+}
+function PdfViewerProvider({
+  src,
+  defaultPage = 1,
+  defaultZoom = DEFAULT_ZOOM,
+  defaultCursorMode = "select",
+  defaultSidebarOpen = false,
+  onPageChange,
+  onDocumentLoad,
+  children
+}) {
+  const { document, isLoading, error } = usePdfDocument(src, onDocumentLoad);
+  const totalPages = document?.numPages ?? 0;
+  const containerRef = useRef2(null);
+  const scrollToPageRef = useRef2(null);
+  const [currentPage, setCurrentPage] = useState2(defaultPage);
+  const isMobile = typeof window !== "undefined" && window.innerWidth <= 640;
+  const [zoomLevel, setZoomLevel] = useState2(
+    typeof defaultZoom === "number" ? defaultZoom : DEFAULT_ZOOM
+  );
+  const [zoomMode, setZoomMode] = useState2(
+    typeof defaultZoom === "string" ? defaultZoom : isMobile ? "fit-width" : null
+  );
+  const [rotation, setRotation] = useState2(0);
+  const [isThumbnailsOpen, setIsThumbnailsOpen] = useState2(defaultSidebarOpen);
+  const [searchQuery, setSearchQuery] = useState2("");
+  const [searchMatches, setSearchMatches] = useState2([]);
+  const [currentMatchIndex, setCurrentMatchIndex] = useState2(-1);
+  const [cursorMode, setCursorModeState] = useState2(defaultCursorMode);
+  const [viewMode, setViewModeState] = useState2("single");
+  const [scrollMode, setScrollModeState] = useState2("vertical");
+  const [isDocPropertiesOpen, setIsDocPropertiesOpen] = useState2(false);
+  const [docProperties, setDocProperties] = useState2(null);
+  const [isPrinting, setIsPrinting] = useState2(false);
+  const currentPageRef = useRef2(defaultPage);
+  const _setCurrentPage = useCallback(
+    (page) => {
+      const clamped = Math.max(1, Math.min(page, totalPages));
+      if (currentPageRef.current === clamped) return;
+      currentPageRef.current = clamped;
+      setCurrentPage(clamped);
+      onPageChange?.(clamped);
+    },
+    [totalPages, onPageChange]
+  );
+  const goToPage = useCallback(
+    (page) => {
+      const clamped = Math.max(1, Math.min(page, totalPages));
+      currentPageRef.current = clamped;
+      setCurrentPage(clamped);
+      onPageChange?.(clamped);
+      scrollToPageRef.current?.(clamped);
+    },
+    [totalPages, onPageChange]
+  );
+  const nextPage = useCallback(() => {
+    goToPage(currentPageRef.current + 1);
+  }, [goToPage]);
+  const prevPage = useCallback(() => {
+    goToPage(currentPageRef.current - 1);
+  }, [goToPage]);
+  const zoomIn = useCallback(() => {
+    setZoomLevel((prev) => Math.min(prev + ZOOM_STEP, MAX_ZOOM));
+    setZoomMode(null);
+  }, []);
+  const zoomOut = useCallback(() => {
+    setZoomLevel((prev) => Math.max(prev - ZOOM_STEP, MIN_ZOOM));
+    setZoomMode(null);
+  }, []);
+  const zoomTo = useCallback((value2) => {
+    if (typeof value2 === "number") {
+      setZoomLevel(Math.max(MIN_ZOOM, Math.min(value2, MAX_ZOOM)));
+      setZoomMode(null);
+    } else {
+      setZoomMode(value2);
+    }
+  }, []);
+  const _setZoomLevel = useCallback((level) => {
+    setZoomLevel(Math.max(MIN_ZOOM, Math.min(level, MAX_ZOOM)));
+  }, []);
+  const rotate = useCallback((degrees = 90) => {
+    setRotation((prev) => (prev + degrees) % 360);
+  }, []);
+  const toggleThumbnails = useCallback(() => {
+    setIsThumbnailsOpen((prev) => !prev);
+  }, []);
+  const search = useCallback(async (query) => {
+    setSearchQuery(query);
+    if (!query || !document) {
+      setSearchMatches([]);
+      setCurrentMatchIndex(-1);
+      return;
+    }
+    const matches = [];
+    const lowerQuery = query.toLowerCase();
+    for (let i = 1; i <= document.numPages; i++) {
+      const page = await document.getPage(i);
+      const textContent = await page.getTextContent();
+      const pageText = textContent.items.map((item) => item.str).join(" ").toLowerCase();
+      let startIndex = 0;
+      let matchIdx = 0;
+      while ((startIndex = pageText.indexOf(lowerQuery, startIndex)) !== -1) {
+        matches.push({ pageIndex: i - 1, matchIndex: matchIdx++ });
+        startIndex += lowerQuery.length;
+      }
+    }
+    setSearchMatches(matches);
+    setCurrentMatchIndex(matches.length > 0 ? 0 : -1);
+  }, [document]);
+  const navigateToMatch = useCallback((matchIndex) => {
+    if (matchIndex < 0 || matchIndex >= searchMatches.length) return;
+    const match = searchMatches[matchIndex];
+    goToPage(match.pageIndex + 1);
+    requestAnimationFrame(() => {
+      requestAnimationFrame(() => {
+        const el = containerRef?.current?.querySelector(".pdf-viewer__search-hit--current");
+        el?.scrollIntoView({ block: "center", behavior: "instant" });
+      });
+    });
+  }, [searchMatches, goToPage, containerRef]);
+  const nextMatch = useCallback(() => {
+    if (searchMatches.length === 0) return;
+    setCurrentMatchIndex((prev) => {
+      const next = (prev + 1) % searchMatches.length;
+      navigateToMatch(next);
+      return next;
+    });
+  }, [searchMatches.length, navigateToMatch]);
+  const prevMatch = useCallback(() => {
+    if (searchMatches.length === 0) return;
+    setCurrentMatchIndex((prev) => {
+      const next = (prev - 1 + searchMatches.length) % searchMatches.length;
+      navigateToMatch(next);
+      return next;
+    });
+  }, [searchMatches.length, navigateToMatch]);
+  const clearSearch = useCallback(() => {
+    setSearchQuery("");
+    setSearchMatches([]);
+    setCurrentMatchIndex(-1);
+  }, []);
+  const download = useCallback(
+    async (fileName) => {
+      if (!document) return;
+      const data = await document.getData();
+      const blob = new Blob([data], { type: "application/pdf" });
+      const url = URL.createObjectURL(blob);
+      const a = window.document.createElement("a");
+      a.href = url;
+      a.download = fileName ?? "document.pdf";
+      window.document.body.appendChild(a);
+      a.click();
+      window.document.body.removeChild(a);
+      URL.revokeObjectURL(url);
+    },
+    [document]
+  );
+  const print = useCallback(async () => {
+    if (!document) return;
+    const total = document.numPages;
+    setIsPrinting(true);
+    await new Promise((resolve) => {
+      const checkInterval = setInterval(() => {
+        const container2 = containerRef.current;
+        if (!container2) return;
+        const canvases2 = container2.querySelectorAll(".pdf-viewer__page-canvas");
+        let rendered = 0;
+        canvases2.forEach((c) => {
+          const canvas = c;
+          if (canvas.width > 0 && canvas.height > 0) rendered++;
+        });
+        if (rendered >= total) {
+          clearInterval(checkInterval);
+          resolve();
+        }
+      }, 100);
+      setTimeout(() => {
+        clearInterval(checkInterval);
+        resolve();
+      }, 1e4);
+    });
+    const container = containerRef.current;
+    if (!container) {
+      setIsPrinting(false);
+      return;
+    }
+    const canvases = Array.from(container.querySelectorAll(".pdf-viewer__page-canvas"));
+    const iframe = window.document.createElement("iframe");
+    iframe.style.position = "fixed";
+    iframe.style.top = "-10000px";
+    iframe.style.left = "-10000px";
+    iframe.style.width = "0";
+    iframe.style.height = "0";
+    window.document.body.appendChild(iframe);
+    const iframeDoc = iframe.contentDocument || iframe.contentWindow?.document;
+    if (!iframeDoc) {
+      setIsPrinting(false);
+      return;
+    }
+    iframeDoc.open();
+    iframeDoc.write(`<!DOCTYPE html><html><head><style>
+      * { margin: 0; padding: 0; }
+      body { background: white; }
+      img { display: block; width: 100%; height: auto; page-break-after: always; }
+      img:last-child { page-break-after: auto; }
+    </style></head><body></body></html>`);
+    iframeDoc.close();
+    for (const canvas of canvases) {
+      const img = iframeDoc.createElement("img");
+      img.src = canvas.toDataURL("image/png");
+      iframeDoc.body.appendChild(img);
+    }
+    await new Promise((resolve) => {
+      const imgs = iframeDoc.querySelectorAll("img");
+      let loaded = 0;
+      const onLoad = () => {
+        loaded++;
+        if (loaded >= imgs.length) resolve();
+      };
+      imgs.forEach((img) => {
+        if (img.complete) {
+          loaded++;
+        } else {
+          img.onload = onLoad;
+        }
+      });
+      if (loaded >= imgs.length) resolve();
+    });
+    iframe.contentWindow?.print();
+    setTimeout(() => {
+      window.document.body.removeChild(iframe);
+      setIsPrinting(false);
+    }, 500);
+  }, [document]);
+  const setCursorMode = useCallback((mode) => {
+    setCursorModeState(mode);
+  }, []);
+  const toggleCursorMode = useCallback(() => {
+    setCursorModeState((prev) => prev === "select" ? "hand" : "select");
+  }, []);
+  const goToFirstPage = useCallback(() => {
+    goToPage(1);
+  }, [goToPage]);
+  const goToLastPage = useCallback(() => {
+    goToPage(totalPages);
+  }, [goToPage, totalPages]);
+  const setViewMode = useCallback((mode) => {
+    setViewModeState(mode);
+    if (mode === "dual") {
+      setScrollModeState((prev) => prev === "horizontal" ? "vertical" : prev);
+    }
+  }, []);
+  const setScrollMode = useCallback((mode) => {
+    setScrollModeState(mode);
+    if (mode === "horizontal") {
+      setViewModeState("single");
+    }
+  }, []);
+  const layoutMode = scrollMode === "horizontal" ? "horizontal" : viewMode === "dual" ? "dual" : "single";
+  const setLayoutMode = useCallback((mode) => {
+    if (mode === "horizontal") {
+      setScrollModeState("horizontal");
+      setViewModeState("single");
+    } else if (mode === "dual") {
+      setViewModeState("dual");
+      setScrollModeState((prev) => prev === "horizontal" ? "vertical" : prev);
+    } else {
+      setViewModeState("single");
+    }
+  }, []);
+  const openDocProperties = useCallback(async () => {
+    if (!document) return;
+    try {
+      const metadata = await document.getMetadata();
+      const info = metadata?.info ?? {};
+      const page = await document.getPage(1);
+      const viewport = page.getViewport({ scale: 1 });
+      const widthIn = (viewport.width / 72).toFixed(1);
+      const heightIn = (viewport.height / 72).toFixed(1);
+      const widthMm = (viewport.width / 72 * 25.4).toFixed(0);
+      const heightMm = (viewport.height / 72 * 25.4).toFixed(0);
+      const formatDate = (raw) => {
+        if (!raw) return "-";
+        const match = raw.match(/D:(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/);
+        if (match) {
+          const [, y, m, d, h, min, s] = match;
+          return (/* @__PURE__ */ new Date(`${y}-${m}-${d}T${h}:${min}:${s}`)).toLocaleString();
+        }
+        return raw;
+      };
+      const formatFileSize = (bytes) => {
+        if (bytes < 1024) return `${bytes} B`;
+        if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+        if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+        return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+      };
+      const data = await document.getData();
+      let fileName = "-";
+      if (typeof src === "string") {
+        const urlPath = src.split("?")[0].split("#")[0];
+        const lastSegment = urlPath.split("/").pop();
+        if (lastSegment) fileName = decodeURIComponent(lastSegment);
+      } else if (src instanceof File) {
+        fileName = src.name;
+      }
+      setDocProperties({
+        fileName,
+        fileSize: formatFileSize(data.byteLength),
+        title: info.Title || "-",
+        author: info.Author || "-",
+        subject: info.Subject || "-",
+        creator: info.Creator || "-",
+        producer: info.Producer || "-",
+        creationDate: formatDate(info.CreationDate),
+        modificationDate: formatDate(info.ModDate),
+        pageCount: document.numPages,
+        pageSize: `${widthIn} \xD7 ${heightIn} in (${widthMm} \xD7 ${heightMm} mm)`
+      });
+      setIsDocPropertiesOpen(true);
+    } catch {
+    }
+  }, [document, src]);
+  const closeDocProperties = useCallback(() => {
+    setIsDocPropertiesOpen(false);
+  }, []);
+  const toggleFullScreen = useCallback(() => {
+    if (!window.document.fullscreenElement) {
+      const el = containerRef.current?.closest(".pdf-viewer") ?? window.document.documentElement;
+      el.requestFullscreen?.();
+    } else {
+      window.document.exitFullscreen?.();
+    }
+  }, []);
+  const value = useMemo(
+    () => ({
+      document,
+      isLoading,
+      error,
+      currentPage,
+      totalPages,
+      zoomLevel,
+      zoomMode,
+      rotation,
+      isThumbnailsOpen,
+      searchQuery,
+      searchMatches,
+      currentMatchIndex,
+      isPrinting,
+      containerRef,
+      scrollToPageRef,
+      _setCurrentPage,
+      goToPage,
+      nextPage,
+      prevPage,
+      zoomIn,
+      zoomOut,
+      zoomTo,
+      _setZoomLevel,
+      rotate,
+      toggleThumbnails,
+      search,
+      nextMatch,
+      prevMatch,
+      clearSearch,
+      download,
+      print,
+      toggleFullScreen,
+      cursorMode,
+      setCursorMode,
+      toggleCursorMode,
+      viewMode,
+      scrollMode,
+      layoutMode,
+      setViewMode,
+      setScrollMode,
+      setLayoutMode,
+      isDocPropertiesOpen,
+      docProperties,
+      goToFirstPage,
+      goToLastPage,
+      openDocProperties,
+      closeDocProperties
+    }),
+    [
+      document,
+      isLoading,
+      error,
+      currentPage,
+      totalPages,
+      zoomLevel,
+      zoomMode,
+      rotation,
+      isThumbnailsOpen,
+      searchQuery,
+      searchMatches,
+      currentMatchIndex,
+      isPrinting,
+      _setCurrentPage,
+      goToPage,
+      nextPage,
+      prevPage,
+      zoomIn,
+      zoomOut,
+      zoomTo,
+      _setZoomLevel,
+      rotate,
+      toggleThumbnails,
+      search,
+      nextMatch,
+      prevMatch,
+      clearSearch,
+      download,
+      print,
+      toggleFullScreen,
+      cursorMode,
+      setCursorMode,
+      toggleCursorMode,
+      viewMode,
+      scrollMode,
+      layoutMode,
+      setViewMode,
+      setScrollMode,
+      setLayoutMode,
+      isDocPropertiesOpen,
+      docProperties,
+      goToFirstPage,
+      goToLastPage,
+      openDocProperties,
+      closeDocProperties
+    ]
+  );
+  return /* @__PURE__ */ jsx(PdfViewerContext.Provider, { value, children });
+}
+
+// src/hooks/use-keyboard-shortcuts.ts
+import { useEffect as useEffect2 } from "react";
+function useKeyboardShortcuts(containerRef, ctx) {
+  useEffect2(() => {
+    const el = containerRef.current;
+    if (!el) return;
+    const handleKeyDown = (e) => {
+      const target = e.target;
+      const isInput = target.tagName === "INPUT" || target.tagName === "TEXTAREA";
+      if (!isInput) {
+        if (e.key === "ArrowRight" || e.key === "PageDown") {
+          e.preventDefault();
+          ctx.nextPage();
+        }
+        if (e.key === "ArrowLeft" || e.key === "PageUp") {
+          e.preventDefault();
+          ctx.prevPage();
+        }
+      }
+      if (!isInput && e.key === "h") {
+        e.preventDefault();
+        ctx.toggleCursorMode();
+      }
+      if (e.ctrlKey || e.metaKey) {
+        if (e.key === "=" || e.key === "+") {
+          e.preventDefault();
+          ctx.zoomIn();
+        }
+        if (e.key === "-") {
+          e.preventDefault();
+          ctx.zoomOut();
+        }
+        if (e.key === "0") {
+          e.preventDefault();
+          ctx.zoomTo(1);
+        }
+        if (e.key === "f") {
+          e.preventDefault();
+          const searchInput = el.querySelector(".pdf-viewer__search-input");
+          searchInput?.focus();
+        }
+      }
+    };
+    el.addEventListener("keydown", handleKeyDown);
+    return () => el.removeEventListener("keydown", handleKeyDown);
+  }, [containerRef, ctx]);
+}
+
+// src/components/Root.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function RootInner({ className, theme, children }) {
+  const containerRef = useRef3(null);
+  const ctx = usePdfViewerContext();
+  useKeyboardShortcuts(containerRef, ctx);
+  const classNames = [
+    "pdf-viewer",
+    ctx.isLoading && "pdf-viewer--loading",
+    ctx.error && "pdf-viewer--error",
+    className
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsx2(
+    "div",
+    {
+      ref: containerRef,
+      className: classNames,
+      "data-theme": theme,
+      tabIndex: -1,
+      children: ctx.error ? /* @__PURE__ */ jsx2("div", { className: "pdf-viewer__error", children: /* @__PURE__ */ jsx2("p", { children: ctx.error.message }) }) : children
+    }
+  );
+}
+function Root({
+  src,
+  defaultPage,
+  defaultZoom,
+  defaultCursorMode,
+  defaultSidebarOpen,
+  theme = "system",
+  onPageChange,
+  onDocumentLoad,
+  className,
+  children
+}) {
+  return /* @__PURE__ */ jsx2(
+    PdfViewerProvider,
+    {
+      src,
+      defaultPage,
+      defaultZoom,
+      defaultCursorMode,
+      defaultSidebarOpen,
+      onPageChange,
+      onDocumentLoad,
+      children: /* @__PURE__ */ jsx2(RootInner, { className, theme, children })
+    }
+  );
+}
+
+// src/components/Toolbar.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+function Toolbar({ className, children }) {
+  const classNames = ["pdf-viewer__toolbar", className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsx3("div", { className: classNames, role: "toolbar", children });
+}
+
+// src/components/Navigation.tsx
+import { useState as useState3, useEffect as useEffect3, useCallback as useCallback2 } from "react";
+
+// src/icons.tsx
+import { jsx as jsx4, jsxs } from "react/jsx-runtime";
+var defaults = {
+  width: 18,
+  height: 18,
+  viewBox: "0 0 24 24",
+  fill: "none",
+  stroke: "currentColor",
+  strokeWidth: 2,
+  strokeLinecap: "round",
+  strokeLinejoin: "round"
+};
+function Icon(props) {
+  const { children, ...rest } = props;
+  return /* @__PURE__ */ jsx4("svg", { ...defaults, ...rest, children });
+}
+function ChevronLeft(props) {
+  return /* @__PURE__ */ jsx4(Icon, { ...props, children: /* @__PURE__ */ jsx4("path", { d: "m15 18-6-6 6-6" }) });
+}
+function ChevronRight(props) {
+  return /* @__PURE__ */ jsx4(Icon, { ...props, children: /* @__PURE__ */ jsx4("path", { d: "m9 18 6-6-6-6" }) });
+}
+function ChevronUp(props) {
+  return /* @__PURE__ */ jsx4(Icon, { ...props, children: /* @__PURE__ */ jsx4("path", { d: "m18 15-6-6-6 6" }) });
+}
+function ChevronDown(props) {
+  return /* @__PURE__ */ jsx4(Icon, { ...props, children: /* @__PURE__ */ jsx4("path", { d: "m6 9 6 6 6-6" }) });
+}
+function Minus(props) {
+  return /* @__PURE__ */ jsx4(Icon, { ...props, children: /* @__PURE__ */ jsx4("path", { d: "M5 12h14" }) });
+}
+function Plus(props) {
+  return /* @__PURE__ */ jsxs(Icon, { ...props, children: [
+    /* @__PURE__ */ jsx4("path", { d: "M5 12h14" }),
+    /* @__PURE__ */ jsx4("path", { d: "M12 5v14" })
+  ] });
+}
+function ArrowLeftRight(props) {
+  return /* @__PURE__ */ jsxs(Icon, { ...props, children: [
+    /* @__PURE__ */ jsx4("path", { d: "M8 3H5a2 2 0 0 0-2 2v3" }),
+    /* @__PURE__ */ jsx4("path", { d: "M21 8V5a2 2 0 0 0-2-2h-3" }),
+    /* @__PURE__ */ jsx4("path", { d: "M3 16v3a2 2 0 0 0 2 2h3" }),
+    /* @__PURE__ */ jsx4("path", { d: "M16 21h3a2 2 0 0 0 2-2v-3" }),
+    /* @__PURE__ */ jsx4("path", { d: "M7 12h10" })
+  ] });
+}
+function RectangleVertical(props) {
+  return /* @__PURE__ */ jsx4(Icon, { ...props, children: /* @__PURE__ */ jsx4("rect", { width: "12", height: "18", x: "6", y: "3", rx: "2" }) });
+}
+function SearchIcon(props) {
+  return /* @__PURE__ */ jsxs(Icon, { ...props, children: [
+    /* @__PURE__ */ jsx4("circle", { cx: "11", cy: "11", r: "8" }),
+    /* @__PURE__ */ jsx4("path", { d: "m21 21-4.3-4.3" })
+  ] });
+}
+function X(props) {
+  return /* @__PURE__ */ jsxs(Icon, { ...props, children: [
+    /* @__PURE__ */ jsx4("path", { d: "M18 6 6 18" }),
+    /* @__PURE__ */ jsx4("path", { d: "m6 6 12 12" })
+  ] });
+}
+function RotateCw(props) {
+  return /* @__PURE__ */ jsxs(Icon, { ...props, children: [
+    /* @__PURE__ */ jsx4("path", { d: "M21 12a9 9 0 1 1-9-9c2.52 0 4.93 1 6.74 2.74L21 8" }),
+    /* @__PURE__ */ jsx4("path", { d: "M21 3v5h-5" })
+  ] });
+}
+function RotateCcw(props) {
+  return /* @__PURE__ */ jsxs(Icon, { ...props, children: [
+    /* @__PURE__ */ jsx4("path", { d: "M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8" }),
+    /* @__PURE__ */ jsx4("path", { d: "M3 3v5h5" })
+  ] });
+}
+function Download(props) {
+  return /* @__PURE__ */ jsxs(Icon, { ...props, children: [
+    /* @__PURE__ */ jsx4("path", { d: "M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" }),
+    /* @__PURE__ */ jsx4("polyline", { points: "7 10 12 15 17 10" }),
+    /* @__PURE__ */ jsx4("line", { x1: "12", x2: "12", y1: "15", y2: "3" })
+  ] });
+}
+function Printer(props) {
+  return /* @__PURE__ */ jsxs(Icon, { ...props, children: [
+    /* @__PURE__ */ jsx4("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__ */ jsx4("path", { d: "M6 9V3h12v6" }),
+    /* @__PURE__ */ jsx4("rect", { width: "12", height: "8", x: "6", y: "14" })
+  ] });
+}
+function Maximize(props) {
+  return /* @__PURE__ */ jsxs(Icon, { ...props, children: [
+    /* @__PURE__ */ jsx4("path", { d: "M8 3H5a2 2 0 0 0-2 2v3" }),
+    /* @__PURE__ */ jsx4("path", { d: "M21 8V5a2 2 0 0 0-2-2h-3" }),
+    /* @__PURE__ */ jsx4("path", { d: "M3 16v3a2 2 0 0 0 2 2h3" }),
+    /* @__PURE__ */ jsx4("path", { d: "M16 21h3a2 2 0 0 0 2-2v-3" })
+  ] });
+}
+function Expand(props) {
+  return /* @__PURE__ */ jsxs(Icon, { ...props, children: [
+    /* @__PURE__ */ jsx4("path", { d: "m21 21-6-6m6 6v-4.8m0 4.8h-4.8" }),
+    /* @__PURE__ */ jsx4("path", { d: "M3 16.2V21m0 0h4.8M3 21l6-6" }),
+    /* @__PURE__ */ jsx4("path", { d: "M21 7.8V3m0 0h-4.8M21 3l-6 6" }),
+    /* @__PURE__ */ jsx4("path", { d: "M3 7.8V3m0 0h4.8M3 3l6 6" })
+  ] });
+}
+function Hand(props) {
+  return /* @__PURE__ */ jsxs(Icon, { ...props, children: [
+    /* @__PURE__ */ jsx4("path", { d: "M18 11V6a2 2 0 0 0-2-2 2 2 0 0 0-2 2" }),
+    /* @__PURE__ */ jsx4("path", { d: "M14 10V4a2 2 0 0 0-2-2 2 2 0 0 0-2 2v2" }),
+    /* @__PURE__ */ jsx4("path", { d: "M10 10.5V6a2 2 0 0 0-2-2 2 2 0 0 0-2 2v8" }),
+    /* @__PURE__ */ jsx4("path", { d: "M18 8a2 2 0 1 1 4 0v6a8 8 0 0 1-8 8h-2c-2.8 0-4.5-.86-5.99-2.34l-3.6-3.6a2 2 0 0 1 2.83-2.82L7 15" })
+  ] });
+}
+function MousePointer(props) {
+  return /* @__PURE__ */ jsx4(Icon, { ...props, children: /* @__PURE__ */ jsx4("path", { d: "M3 3l7.07 17 2.51-7.39L20 10.07z" }) });
+}
+function StickyNote(props) {
+  return /* @__PURE__ */ jsxs(Icon, { ...props, children: [
+    /* @__PURE__ */ jsx4("path", { d: "M15.5 3H5a2 2 0 0 0-2 2v14c0 1.1.9 2 2 2h14a2 2 0 0 0 2-2V8.5L15.5 3Z" }),
+    /* @__PURE__ */ jsx4("path", { d: "M14 3v4a2 2 0 0 0 2 2h4" })
+  ] });
+}
+function Columns2(props) {
+  return /* @__PURE__ */ jsxs(Icon, { ...props, children: [
+    /* @__PURE__ */ jsx4("rect", { width: "18", height: "18", x: "3", y: "3", rx: "2" }),
+    /* @__PURE__ */ jsx4("path", { d: "M12 3v18" })
+  ] });
+}
+function GalleryVertical(props) {
+  return /* @__PURE__ */ jsxs(Icon, { ...props, children: [
+    /* @__PURE__ */ jsx4("path", { d: "M3 2h18" }),
+    /* @__PURE__ */ jsx4("rect", { width: "18", height: "12", x: "3", y: "6", rx: "2" }),
+    /* @__PURE__ */ jsx4("path", { d: "M3 22h18" })
+  ] });
+}
+function GalleryHorizontal(props) {
+  return /* @__PURE__ */ jsxs(Icon, { ...props, children: [
+    /* @__PURE__ */ jsx4("path", { d: "M2 3v18" }),
+    /* @__PURE__ */ jsx4("rect", { width: "12", height: "18", x: "6", y: "3", rx: "2" }),
+    /* @__PURE__ */ jsx4("path", { d: "M22 3v18" })
+  ] });
+}
+function GalleryThumbnails(props) {
+  return /* @__PURE__ */ jsxs(Icon, { ...props, children: [
+    /* @__PURE__ */ jsx4("rect", { width: "18", height: "14", x: "3", y: "2", rx: "2" }),
+    /* @__PURE__ */ jsx4("rect", { width: "4", height: "2", x: "4", y: "18", rx: "1" }),
+    /* @__PURE__ */ jsx4("rect", { width: "4", height: "2", x: "10", y: "18", rx: "1" }),
+    /* @__PURE__ */ jsx4("rect", { width: "4", height: "2", x: "16", y: "18", rx: "1" })
+  ] });
+}
+function Check(props) {
+  return /* @__PURE__ */ jsx4(Icon, { ...props, children: /* @__PURE__ */ jsx4("path", { d: "M20 6 9 17l-5-5" }) });
+}
+function EllipsisVertical(props) {
+  return /* @__PURE__ */ jsxs(Icon, { ...props, children: [
+    /* @__PURE__ */ jsx4("circle", { cx: "12", cy: "12", r: "1" }),
+    /* @__PURE__ */ jsx4("circle", { cx: "12", cy: "5", r: "1" }),
+    /* @__PURE__ */ jsx4("circle", { cx: "12", cy: "19", r: "1" })
+  ] });
+}
+function Info(props) {
+  return /* @__PURE__ */ jsxs(Icon, { ...props, children: [
+    /* @__PURE__ */ jsx4("circle", { cx: "12", cy: "12", r: "10" }),
+    /* @__PURE__ */ jsx4("path", { d: "M12 16v-4" }),
+    /* @__PURE__ */ jsx4("path", { d: "M12 8h.01" })
+  ] });
+}
+function PanelLeft(props) {
+  return /* @__PURE__ */ jsxs(Icon, { ...props, children: [
+    /* @__PURE__ */ jsx4("rect", { width: "18", height: "18", x: "3", y: "3", rx: "2" }),
+    /* @__PURE__ */ jsx4("path", { d: "M9 3v18" })
+  ] });
+}
+function ArrowDownToLine(props) {
+  return /* @__PURE__ */ jsxs(Icon, { ...props, children: [
+    /* @__PURE__ */ jsx4("path", { d: "M12 17V3" }),
+    /* @__PURE__ */ jsx4("path", { d: "m6 11 6 6 6-6" }),
+    /* @__PURE__ */ jsx4("path", { d: "M19 21H5" })
+  ] });
+}
+
+// src/components/Navigation.tsx
+import { jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
+function Navigation({ className }) {
+  const { currentPage, totalPages, goToPage, nextPage, prevPage } = usePdfViewerContext();
+  const [inputValue, setInputValue] = useState3(String(currentPage));
+  useEffect3(() => {
+    setInputValue(String(currentPage));
+  }, [currentPage]);
+  const handleInputChange = useCallback2((e) => {
+    setInputValue(e.target.value);
+  }, []);
+  const handleKeyDown = useCallback2(
+    (e) => {
+      if (e.key === "Enter") {
+        const page = parseInt(inputValue, 10);
+        if (!isNaN(page)) {
+          goToPage(page);
+        }
+      }
+    },
+    [inputValue, goToPage]
+  );
+  const handleBlur = useCallback2(() => {
+    setInputValue(String(currentPage));
+  }, [currentPage]);
+  const classNames = ["pdf-viewer__navigation", className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxs2("div", { className: classNames, children: [
+    /* @__PURE__ */ jsx5(
+      "button",
+      {
+        className: "pdf-viewer__btn",
+        onClick: prevPage,
+        disabled: currentPage <= 1,
+        title: "Previous page",
+        "aria-label": "Previous page",
+        children: /* @__PURE__ */ jsx5(ChevronLeft, {})
+      }
+    ),
+    /* @__PURE__ */ jsx5(
+      "input",
+      {
+        className: "pdf-viewer__page-input",
+        type: "text",
+        value: inputValue,
+        onChange: handleInputChange,
+        onKeyDown: handleKeyDown,
+        onBlur: handleBlur,
+        "aria-label": "Page number"
+      }
+    ),
+    /* @__PURE__ */ jsxs2("span", { className: "pdf-viewer__page-count", children: [
+      /* @__PURE__ */ jsxs2("span", { className: "pdf-viewer__page-count-desktop", children: [
+        "of ",
+        totalPages
+      ] }),
+      /* @__PURE__ */ jsxs2("span", { className: "pdf-viewer__page-count-mobile", children: [
+        "/",
+        totalPages
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx5(
+      "button",
+      {
+        className: "pdf-viewer__btn",
+        onClick: nextPage,
+        disabled: currentPage >= totalPages,
+        title: "Next page",
+        "aria-label": "Next page",
+        children: /* @__PURE__ */ jsx5(ChevronRight, {})
+      }
+    )
+  ] });
+}
+
+// src/components/DropdownMenu.tsx
+import { useState as useState4, useRef as useRef4, useEffect as useEffect4, useCallback as useCallback3 } from "react";
+import { jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
+function DropdownMenu({ trigger, children, className, align = "right", title = "More actions", triggerClassName }) {
+  const [open, setOpen] = useState4(false);
+  const menuRef = useRef4(null);
+  const close = useCallback3(() => setOpen(false), []);
+  useEffect4(() => {
+    if (!open) return;
+    const handleClickOutside = (e) => {
+      if (menuRef.current && !menuRef.current.contains(e.target)) {
+        close();
+      }
+    };
+    const handleEscape = (e) => {
+      if (e.key === "Escape") close();
+    };
+    window.document.addEventListener("mousedown", handleClickOutside);
+    window.document.addEventListener("keydown", handleEscape);
+    return () => {
+      window.document.removeEventListener("mousedown", handleClickOutside);
+      window.document.removeEventListener("keydown", handleEscape);
+    };
+  }, [open, close]);
+  const classNames = ["pdf-viewer__dropdown", className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxs3("div", { ref: menuRef, className: classNames, children: [
+    /* @__PURE__ */ jsx6(
+      "button",
+      {
+        className: triggerClassName ?? "pdf-viewer__btn",
+        onClick: () => setOpen((prev) => !prev),
+        "aria-haspopup": "menu",
+        "aria-expanded": open,
+        title,
+        "aria-label": title,
+        children: trigger
+      }
+    ),
+    open && /* @__PURE__ */ jsx6(
+      "div",
+      {
+        className: `pdf-viewer__dropdown-content pdf-viewer__dropdown-content--${align}`,
+        role: "menu",
+        onClick: close,
+        children
+      }
+    )
+  ] });
+}
+function DropdownMenuItem({ icon, label, onClick, disabled, active }) {
+  const classNames = [
+    "pdf-viewer__dropdown-item",
+    active && "pdf-viewer__dropdown-item--active",
+    disabled && "pdf-viewer__dropdown-item--disabled"
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxs3(
+    "button",
+    {
+      className: classNames,
+      role: "menuitem",
+      onClick: disabled ? void 0 : onClick,
+      disabled,
+      children: [
+        icon && /* @__PURE__ */ jsx6("span", { className: "pdf-viewer__dropdown-item-icon", children: icon }),
+        /* @__PURE__ */ jsx6("span", { className: "pdf-viewer__dropdown-item-label", children: label }),
+        active && /* @__PURE__ */ jsx6("span", { className: "pdf-viewer__dropdown-item-check", children: /* @__PURE__ */ jsx6(Check, {}) })
+      ]
+    }
+  );
+}
+function DropdownMenuSeparator() {
+  return /* @__PURE__ */ jsx6("div", { className: "pdf-viewer__dropdown-separator", role: "separator" });
+}
+
+// src/components/Zoom.tsx
+import { jsx as jsx7, jsxs as jsxs4 } from "react/jsx-runtime";
+var ZOOM_PRESETS = [0.5, 0.75, 1, 1.25, 1.5, 2, 3];
+function Zoom({ className }) {
+  const { zoomLevel, zoomMode, zoomIn, zoomOut, zoomTo } = usePdfViewerContext();
+  const classNames = ["pdf-viewer__zoom", className].filter(Boolean).join(" ");
+  const displayPercent = `${Math.round(zoomLevel * 20) * 5}%`;
+  const isPresetActive = (preset) => !zoomMode && Math.abs(zoomLevel - preset) < 0.01;
+  return /* @__PURE__ */ jsxs4("div", { className: classNames, children: [
+    /* @__PURE__ */ jsx7(
+      "button",
+      {
+        className: "pdf-viewer__btn",
+        onClick: zoomOut,
+        title: "Zoom out",
+        "aria-label": "Zoom out",
+        children: /* @__PURE__ */ jsx7(Minus, {})
+      }
+    ),
+    /* @__PURE__ */ jsxs4(
+      DropdownMenu,
+      {
+        trigger: /* @__PURE__ */ jsx7("span", { className: "pdf-viewer__zoom-level-text", children: displayPercent }),
+        triggerClassName: "pdf-viewer__zoom-trigger",
+        title: "Zoom level",
+        align: "center",
+        className: "pdf-viewer__zoom-dropdown",
+        children: [
+          ZOOM_PRESETS.map((preset) => /* @__PURE__ */ jsx7(
+            DropdownMenuItem,
+            {
+              label: `${Math.round(preset * 100)}%`,
+              onClick: () => zoomTo(preset),
+              active: isPresetActive(preset)
+            },
+            preset
+          )),
+          /* @__PURE__ */ jsx7(DropdownMenuSeparator, {}),
+          /* @__PURE__ */ jsx7(
+            DropdownMenuItem,
+            {
+              icon: /* @__PURE__ */ jsx7(ArrowLeftRight, {}),
+              label: "Fit Width",
+              onClick: () => zoomTo("fit-width"),
+              active: zoomMode === "fit-width"
+            }
+          ),
+          /* @__PURE__ */ jsx7(
+            DropdownMenuItem,
+            {
+              icon: /* @__PURE__ */ jsx7(RectangleVertical, {}),
+              label: "Fit Page",
+              onClick: () => zoomTo("fit-page"),
+              active: zoomMode === "fit-page"
+            }
+          )
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx7(
+      "button",
+      {
+        className: "pdf-viewer__btn",
+        onClick: zoomIn,
+        title: "Zoom in",
+        "aria-label": "Zoom in",
+        children: /* @__PURE__ */ jsx7(Plus, {})
+      }
+    )
+  ] });
+}
+
+// src/components/Search.tsx
+import { useState as useState5, useCallback as useCallback4, useRef as useRef5, useEffect as useEffect5 } from "react";
+import { jsx as jsx8, jsxs as jsxs5 } from "react/jsx-runtime";
+function Search({ className }) {
+  const {
+    searchQuery,
+    searchMatches,
+    currentMatchIndex,
+    search,
+    nextMatch,
+    prevMatch,
+    clearSearch
+  } = usePdfViewerContext();
+  const [open, setOpen] = useState5(false);
+  const panelRef = useRef5(null);
+  const inputRef = useRef5(null);
+  const handleOpen = useCallback4(() => {
+    setOpen(true);
+  }, []);
+  const handleClose = useCallback4(() => {
+    setOpen(false);
+    clearSearch();
+  }, [clearSearch]);
+  const inputCallbackRef = useCallback4((node) => {
+    inputRef.current = node;
+    node?.focus();
+  }, []);
+  useEffect5(() => {
+    if (!open) return;
+    const handleEscape = (e) => {
+      if (e.key === "Escape") handleClose();
+    };
+    window.document.addEventListener("keydown", handleEscape);
+    return () => window.document.removeEventListener("keydown", handleEscape);
+  }, [open, handleClose]);
+  const handleChange = useCallback4(
+    (e) => {
+      search(e.target.value);
+    },
+    [search]
+  );
+  const handleKeyDown = useCallback4(
+    (e) => {
+      if (e.key === "Enter") {
+        if (e.shiftKey) {
+          prevMatch();
+        } else {
+          nextMatch();
+        }
+      }
+    },
+    [nextMatch, prevMatch]
+  );
+  const classNames = ["pdf-viewer__search-toggle", className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxs5("div", { className: classNames, ref: panelRef, children: [
+    /* @__PURE__ */ jsx8(
+      "button",
+      {
+        className: "pdf-viewer__btn",
+        onClick: handleOpen,
+        title: "Search",
+        "aria-label": "Search in document",
+        children: /* @__PURE__ */ jsx8(SearchIcon, {})
+      }
+    ),
+    open && /* @__PURE__ */ jsxs5("div", { className: "pdf-viewer__search-panel", children: [
+      /* @__PURE__ */ jsxs5("div", { className: "pdf-viewer__search-input-wrapper", children: [
+        /* @__PURE__ */ jsx8("div", { className: "pdf-viewer__search-input-icon", children: /* @__PURE__ */ jsx8(SearchIcon, {}) }),
+        /* @__PURE__ */ jsx8(
+          "input",
+          {
+            ref: inputCallbackRef,
+            className: "pdf-viewer__search-panel-input",
+            type: "text",
+            placeholder: "Search...",
+            "aria-label": "Search in document",
+            value: searchQuery,
+            onChange: handleChange,
+            onKeyDown: handleKeyDown
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx8("span", { className: "pdf-viewer__search-count", children: searchQuery && searchMatches.length > 0 ? `${currentMatchIndex + 1}/${searchMatches.length}` : "0/0" }),
+      /* @__PURE__ */ jsx8(
+        "button",
+        {
+          className: "pdf-viewer__btn pdf-viewer__btn--small",
+          onClick: prevMatch,
+          disabled: searchMatches.length === 0,
+          title: "Previous match",
+          "aria-label": "Previous match",
+          children: /* @__PURE__ */ jsx8(ChevronUp, {})
+        }
+      ),
+      /* @__PURE__ */ jsx8(
+        "button",
+        {
+          className: "pdf-viewer__btn pdf-viewer__btn--small",
+          onClick: nextMatch,
+          disabled: searchMatches.length === 0,
+          title: "Next match",
+          "aria-label": "Next match",
+          children: /* @__PURE__ */ jsx8(ChevronDown, {})
+        }
+      ),
+      /* @__PURE__ */ jsx8(
+        "button",
+        {
+          className: "pdf-viewer__btn pdf-viewer__btn--small",
+          onClick: handleClose,
+          title: "Close search",
+          "aria-label": "Close search",
+          children: /* @__PURE__ */ jsx8(X, {})
+        }
+      )
+    ] })
+  ] });
+}
+
+// src/components/Separator.tsx
+import { jsx as jsx9 } from "react/jsx-runtime";
+function Separator({ className }) {
+  const classNames = ["pdf-viewer__separator", className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsx9("div", { className: classNames, role: "separator" });
+}
+
+// src/components/Rotate.tsx
+import { jsx as jsx10 } from "react/jsx-runtime";
+function Rotate({ className }) {
+  const { rotate } = usePdfViewerContext();
+  const classNames = ["pdf-viewer__btn", className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsx10(
+    "button",
+    {
+      className: classNames,
+      onClick: () => rotate(),
+      title: "Rotate",
+      "aria-label": "Rotate clockwise",
+      children: /* @__PURE__ */ jsx10(RotateCw, {})
+    }
+  );
+}
+
+// src/components/Download.tsx
+import { jsx as jsx11 } from "react/jsx-runtime";
+function Download2({ fileName, className }) {
+  const { download } = usePdfViewerContext();
+  const classNames = ["pdf-viewer__btn", className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsx11(
+    "button",
+    {
+      className: classNames,
+      onClick: () => download(fileName),
+      title: "Download",
+      "aria-label": "Download PDF",
+      children: /* @__PURE__ */ jsx11(Download, {})
+    }
+  );
+}
+
+// src/components/Print.tsx
+import { jsx as jsx12 } from "react/jsx-runtime";
+function Print({ className }) {
+  const { print } = usePdfViewerContext();
+  const classNames = ["pdf-viewer__btn", className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsx12(
+    "button",
+    {
+      className: classNames,
+      onClick: print,
+      title: "Print",
+      "aria-label": "Print PDF",
+      children: /* @__PURE__ */ jsx12(Printer, {})
+    }
+  );
+}
+
+// src/components/FullScreen.tsx
+import { jsx as jsx13 } from "react/jsx-runtime";
+function FullScreen({ className }) {
+  const { toggleFullScreen } = usePdfViewerContext();
+  const classNames = ["pdf-viewer__btn", className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsx13(
+    "button",
+    {
+      className: classNames,
+      onClick: toggleFullScreen,
+      title: "Full screen",
+      "aria-label": "Toggle full screen",
+      children: /* @__PURE__ */ jsx13(Expand, {})
+    }
+  );
+}
+
+// src/components/ThumbnailToggle.tsx
+import { jsx as jsx14 } from "react/jsx-runtime";
+function ThumbnailToggle({ className }) {
+  const { toggleThumbnails, isThumbnailsOpen } = usePdfViewerContext();
+  const classNames = [
+    "pdf-viewer__btn",
+    isThumbnailsOpen ? "pdf-viewer__btn--active" : "",
+    className
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsx14(
+    "button",
+    {
+      className: classNames,
+      onClick: toggleThumbnails,
+      title: "Toggle sidebar",
+      "aria-label": "Toggle thumbnails",
+      "aria-pressed": isThumbnailsOpen,
+      children: /* @__PURE__ */ jsx14(PanelLeft, {})
+    }
+  );
+}
+
+// src/components/CursorModeToggle.tsx
+import { jsx as jsx15 } from "react/jsx-runtime";
+function CursorModeToggle({ className }) {
+  const { cursorMode, toggleCursorMode } = usePdfViewerContext();
+  const classNames = ["pdf-viewer__btn", className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsx15(
+    "button",
+    {
+      className: classNames,
+      onClick: toggleCursorMode,
+      title: cursorMode === "select" ? "Hand Tool" : "Selection Mode",
+      "aria-label": cursorMode === "select" ? "Hand Tool" : "Selection Mode",
+      children: cursorMode === "select" ? /* @__PURE__ */ jsx15(Hand, {}) : /* @__PURE__ */ jsx15(MousePointer, {})
+    }
+  );
+}
+
+// src/components/ThumbnailSidebar.tsx
+import { useEffect as useEffect6, useRef as useRef6, useState as useState6, useCallback as useCallback5 } from "react";
+import { jsx as jsx16, jsxs as jsxs6 } from "react/jsx-runtime";
+function ThumbnailSidebar({ className }) {
+  const { document, totalPages, currentPage, goToPage, isThumbnailsOpen, rotation } = usePdfViewerContext();
+  const containerRef = useRef6(null);
+  const [visibleThumbnails, setVisibleThumbnails] = useState6(/* @__PURE__ */ new Set());
+  const [renderedThumbnails, setRenderedThumbnails] = useState6(/* @__PURE__ */ new Set());
+  const canvasRefs = useRef6(/* @__PURE__ */ new Map());
+  const renderingPages = useRef6(/* @__PURE__ */ new Set());
+  const handleIntersection = useCallback5(
+    (entries) => {
+      setVisibleThumbnails((prev) => {
+        const next = new Set(prev);
+        for (const entry of entries) {
+          const pageNum = Number(
+            entry.target.dataset.thumbnailPage
+          );
+          if (entry.isIntersecting) {
+            next.add(pageNum);
+          } else {
+            next.delete(pageNum);
+          }
+        }
+        return next;
+      });
+    },
+    []
+  );
+  useEffect6(() => {
+    const container = containerRef.current;
+    if (!container || !isThumbnailsOpen) return;
+    const observer = new IntersectionObserver(handleIntersection, {
+      root: container,
+      rootMargin: "100px 0px"
+    });
+    const items = container.querySelectorAll("[data-thumbnail-page]");
+    items.forEach((el) => observer.observe(el));
+    return () => observer.disconnect();
+  }, [totalPages, isThumbnailsOpen, handleIntersection]);
+  useEffect6(() => {
+    if (!document || !isThumbnailsOpen) return;
+    let cancelled = false;
+    async function renderQueue() {
+      for (const pageNum of visibleThumbnails) {
+        if (cancelled) break;
+        if (renderedThumbnails.has(pageNum)) continue;
+        if (renderingPages.current.has(pageNum)) continue;
+        const canvas = canvasRefs.current.get(pageNum);
+        if (!canvas) continue;
+        renderingPages.current.add(pageNum);
+        try {
+          const page = await document.getPage(pageNum);
+          if (cancelled) break;
+          const viewport = page.getViewport({ scale: THUMBNAIL_SCALE, rotation });
+          const context = canvas.getContext("2d");
+          if (!context) {
+            renderingPages.current.delete(pageNum);
+            continue;
+          }
+          canvas.width = viewport.width;
+          canvas.height = viewport.height;
+          canvas.style.width = `${viewport.width}px`;
+          canvas.style.height = `${viewport.height}px`;
+          await page.render({ canvasContext: context, viewport }).promise;
+          if (!cancelled) {
+            setRenderedThumbnails((prev) => new Set(prev).add(pageNum));
+          }
+        } catch {
+        } finally {
+          renderingPages.current.delete(pageNum);
+        }
+      }
+    }
+    renderQueue();
+    return () => {
+      cancelled = true;
+    };
+  }, [document, visibleThumbnails, renderedThumbnails, isThumbnailsOpen, rotation]);
+  const lastClickedRef = useRef6(null);
+  useEffect6(() => {
+    const container = containerRef.current;
+    if (!container || !isThumbnailsOpen) return;
+    if (lastClickedRef.current === currentPage) {
+      lastClickedRef.current = null;
+      return;
+    }
+    const active = container.querySelector(`[data-thumbnail-page="${currentPage}"]`);
+    if (!active) return;
+    const containerTop = container.scrollTop;
+    const containerBottom = containerTop + container.clientHeight;
+    const elTop = active.offsetTop - container.offsetTop;
+    const elBottom = elTop + active.offsetHeight;
+    if (elTop < containerTop || elBottom > containerBottom) {
+      container.scrollTo({ top: Math.max(0, elTop - 8) });
+    }
+  }, [currentPage, isThumbnailsOpen]);
+  useEffect6(() => {
+    setRenderedThumbnails(/* @__PURE__ */ new Set());
+  }, [rotation]);
+  if (!isThumbnailsOpen) return null;
+  const classNames = ["pdf-viewer__sidebar", className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsx16("div", { ref: containerRef, className: classNames, children: Array.from({ length: totalPages }, (_, i) => {
+    const pageNum = i + 1;
+    return /* @__PURE__ */ jsxs6(
+      "button",
+      {
+        className: `pdf-viewer__thumbnail${currentPage === pageNum ? " pdf-viewer__thumbnail--active" : ""}`,
+        "data-thumbnail-page": pageNum,
+        onClick: () => {
+          lastClickedRef.current = pageNum;
+          goToPage(pageNum);
+        },
+        children: [
+          /* @__PURE__ */ jsx16(
+            "canvas",
+            {
+              ref: (el) => {
+                if (el) {
+                  canvasRefs.current.set(pageNum, el);
+                } else {
+                  canvasRefs.current.delete(pageNum);
+                }
+              }
+            }
+          ),
+          /* @__PURE__ */ jsx16("span", { children: pageNum })
+        ]
+      },
+      pageNum
+    );
+  }) });
+}
+
+// src/components/Pages.tsx
+import { useCallback as useCallback7, useEffect as useEffect8, useRef as useRef8, useState as useState7 } from "react";
+
+// src/components/Page.tsx
+import { useEffect as useEffect7, useRef as useRef7, useCallback as useCallback6 } from "react";
+import { jsx as jsx17, jsxs as jsxs7 } from "react/jsx-runtime";
+function Page({ pageNumber, className }) {
+  const { document, zoomLevel, rotation, searchQuery, searchMatches, currentMatchIndex } = usePdfViewerContext();
+  const canvasRef = useRef7(null);
+  const textLayerRef = useRef7(null);
+  const renderTaskRef = useRef7(null);
+  const applyHighlightsRef = useRef7(null);
+  const renderPage = useCallback6(async () => {
+    if (!document || !canvasRef.current) return;
+    if (renderTaskRef.current) {
+      renderTaskRef.current.cancel();
+      renderTaskRef.current = null;
+    }
+    try {
+      const page = await document.getPage(pageNumber);
+      const viewport = page.getViewport({ scale: zoomLevel, rotation });
+      const canvas = canvasRef.current;
+      const context = canvas.getContext("2d");
+      if (!context) return;
+      const dpr = window.devicePixelRatio || 1;
+      canvas.width = viewport.width * dpr;
+      canvas.height = viewport.height * dpr;
+      canvas.style.width = `${viewport.width}px`;
+      canvas.style.height = `${viewport.height}px`;
+      context.scale(dpr, dpr);
+      const renderTask = page.render({
+        canvasContext: context,
+        viewport
+      });
+      renderTaskRef.current = renderTask;
+      await renderTask.promise;
+      if (textLayerRef.current) {
+        const textLayerDiv = textLayerRef.current;
+        textLayerDiv.innerHTML = "";
+        textLayerDiv.style.setProperty("--scale-factor", String(viewport.scale));
+        const textContent = await page.getTextContent();
+        const { TextLayer } = await import("pdfjs-dist");
+        const textLayer = new TextLayer({
+          textContentSource: textContent,
+          container: textLayerDiv,
+          viewport
+        });
+        await textLayer.render();
+        requestAnimationFrame(() => applyHighlightsRef.current?.());
+      }
+    } catch (err) {
+      if (err && typeof err === "object" && "name" in err && err.name === "RenderingCancelledException") return;
+    }
+  }, [document, pageNumber, zoomLevel, rotation]);
+  const applyHighlights = useCallback6(() => {
+    const textLayer = textLayerRef.current;
+    if (!textLayer) return;
+    textLayer.querySelectorAll("mark.pdf-viewer__search-hit").forEach((mark) => {
+      const parent = mark.parentNode;
+      if (parent) {
+        parent.replaceChild(window.document.createTextNode(mark.textContent || ""), mark);
+        parent.normalize();
+      }
+    });
+    if (!searchQuery || searchMatches.length === 0) return;
+    const pageMatches = searchMatches.filter((m) => m.pageIndex === pageNumber - 1);
+    if (pageMatches.length === 0) return;
+    const lowerQuery = searchQuery.toLowerCase();
+    const queryLen = searchQuery.length;
+    const spans = Array.from(textLayer.querySelectorAll("span"));
+    let pageMatchIdx = 0;
+    for (const span of spans) {
+      const text = span.textContent || "";
+      const lowerText = text.toLowerCase();
+      let idx = lowerText.indexOf(lowerQuery);
+      if (idx === -1) continue;
+      const frag = window.document.createDocumentFragment();
+      let lastIdx = 0;
+      while (idx !== -1) {
+        if (idx > lastIdx) {
+          frag.appendChild(window.document.createTextNode(text.slice(lastIdx, idx)));
+        }
+        const mark = window.document.createElement("mark");
+        mark.className = "pdf-viewer__search-hit";
+        mark.textContent = text.slice(idx, idx + queryLen);
+        if (pageMatchIdx < pageMatches.length) {
+          const globalIdx = searchMatches.indexOf(pageMatches[pageMatchIdx]);
+          if (globalIdx === currentMatchIndex) {
+            mark.classList.add("pdf-viewer__search-hit--current");
+          }
+        }
+        pageMatchIdx++;
+        frag.appendChild(mark);
+        lastIdx = idx + queryLen;
+        idx = lowerText.indexOf(lowerQuery, lastIdx);
+      }
+      if (lastIdx < text.length) {
+        frag.appendChild(window.document.createTextNode(text.slice(lastIdx)));
+      }
+      span.textContent = "";
+      span.appendChild(frag);
+    }
+  }, [searchQuery, searchMatches, currentMatchIndex, pageNumber]);
+  applyHighlightsRef.current = applyHighlights;
+  useEffect7(() => {
+    applyHighlights();
+  }, [applyHighlights]);
+  useEffect7(() => {
+    renderPage();
+    return () => {
+      if (renderTaskRef.current) {
+        renderTaskRef.current.cancel();
+        renderTaskRef.current = null;
+      }
+    };
+  }, [renderPage]);
+  const classNames = ["pdf-viewer__page", className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxs7("div", { className: classNames, "data-page-number": pageNumber, children: [
+    /* @__PURE__ */ jsx17("canvas", { ref: canvasRef, className: "pdf-viewer__page-canvas" }),
+    /* @__PURE__ */ jsx17("div", { ref: textLayerRef, className: "pdf-viewer__page-text-layer" })
+  ] });
+}
+
+// src/components/Pages.tsx
+import { jsx as jsx18 } from "react/jsx-runtime";
+function Pages({ className }) {
+  const { totalPages, currentPage, _setCurrentPage, zoomMode, zoomLevel, _setZoomLevel, zoomTo, rotation, document: pdfDoc, containerRef: ctxContainerRef, scrollToPageRef, cursorMode, viewMode, scrollMode, isPrinting } = usePdfViewerContext();
+  const containerRef = useRef8(null);
+  const visiblePagesRef = useRef8(/* @__PURE__ */ new Set([1]));
+  const [baseDims, setBaseDims] = useState7(null);
+  const navigatingRef = useRef8(false);
+  const lastReportedPageRef = useRef8(1);
+  const pageUpdateRafRef = useRef8(0);
+  const [renderGeneration, setRenderGeneration] = useState7(0);
+  const computeRenderSet = useCallback7((visible) => {
+    const result = /* @__PURE__ */ new Set();
+    for (const v of visible) {
+      for (let offset = -VIRTUALIZATION_BUFFER; offset <= VIRTUALIZATION_BUFFER; offset++) {
+        const p = v + offset;
+        if (p >= 1 && p <= totalPages) result.add(p);
+      }
+    }
+    return result;
+  }, [totalPages]);
+  const lastRenderSetRef = useRef8(computeRenderSet(/* @__PURE__ */ new Set([1])));
+  const _setCurrentPageRef = useRef8(_setCurrentPage);
+  _setCurrentPageRef.current = _setCurrentPage;
+  const handleIntersection = useCallback7(
+    (entries) => {
+      const prev = visiblePagesRef.current;
+      for (const entry of entries) {
+        const pageNum = Number(
+          entry.target.dataset.pageNumber
+        );
+        if (entry.isIntersecting) {
+          prev.add(pageNum);
+        } else {
+          prev.delete(pageNum);
+        }
+      }
+      const newRenderSet = computeRenderSet(prev);
+      const oldRenderSet = lastRenderSetRef.current;
+      if (newRenderSet.size !== oldRenderSet.size || [...newRenderSet].some((p) => !oldRenderSet.has(p))) {
+        lastRenderSetRef.current = newRenderSet;
+        setRenderGeneration((g) => g + 1);
+      }
+      if (navigatingRef.current) return;
+      cancelAnimationFrame(pageUpdateRafRef.current);
+      pageUpdateRafRef.current = requestAnimationFrame(() => {
+        const visible = visiblePagesRef.current;
+        if (visible.size > 0) {
+          const topmost = Math.min(...visible);
+          if (topmost !== lastReportedPageRef.current) {
+            lastReportedPageRef.current = topmost;
+            _setCurrentPageRef.current(topmost);
+          }
+        }
+      });
+    },
+    [computeRenderSet]
+  );
+  useEffect8(() => {
+    if (!pdfDoc) return;
+    pdfDoc.getPage(1).then((page) => {
+      const vp = page.getViewport({ scale: 1, rotation });
+      setBaseDims({ width: vp.width, height: vp.height });
+    });
+  }, [pdfDoc, rotation]);
+  useEffect8(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const observer = new IntersectionObserver(handleIntersection, {
+      root: container,
+      rootMargin: scrollMode === "horizontal" ? "0px 200px" : "200px 0px"
+    });
+    const wrappers = container.querySelectorAll("[data-page-number]");
+    wrappers.forEach((el) => observer.observe(el));
+    return () => observer.disconnect();
+  }, [totalPages, handleIntersection, scrollMode]);
+  const navigatingTimerRef = useRef8(0);
+  useEffect8(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const handleScrollEnd = () => {
+      if (navigatingRef.current) {
+        clearTimeout(navigatingTimerRef.current);
+        navigatingTimerRef.current = window.setTimeout(() => {
+          navigatingRef.current = false;
+        }, 100);
+      }
+    };
+    container.addEventListener("scrollend", handleScrollEnd);
+    return () => {
+      container.removeEventListener("scrollend", handleScrollEnd);
+      clearTimeout(navigatingTimerRef.current);
+    };
+  }, []);
+  useEffect8(() => {
+    if (!scrollToPageRef) return;
+    scrollToPageRef.current = (page) => {
+      lastReportedPageRef.current = page;
+      if (scrollMode === "page") {
+        navigatingRef.current = false;
+        return;
+      }
+      const container = containerRef.current;
+      if (!container) return;
+      const wrapper = container.querySelector(`[data-page-number="${page}"]`);
+      if (!wrapper) return;
+      const target = (viewMode === "dual" ? wrapper.closest(".pdf-viewer__page-pair") : wrapper) ?? wrapper;
+      navigatingRef.current = true;
+      clearTimeout(navigatingTimerRef.current);
+      navigatingTimerRef.current = window.setTimeout(() => {
+        navigatingRef.current = false;
+      }, 150);
+      if (scrollMode === "horizontal") {
+        container.scrollTo({ left: target.offsetLeft - container.offsetLeft });
+      } else {
+        container.scrollTo({ top: target.offsetTop - container.offsetTop });
+      }
+    };
+  }, [scrollToPageRef, scrollMode, viewMode]);
+  useEffect8(() => {
+    if (containerRef.current && ctxContainerRef) {
+      ctxContainerRef.current = containerRef.current;
+    }
+  });
+  useEffect8(() => {
+    if (!zoomMode || !pdfDoc || !containerRef.current) return;
+    const computeFitZoom = () => {
+      if (!containerRef.current || !pdfDoc) return;
+      pdfDoc.getPage(1).then((page) => {
+        const viewport = page.getViewport({ scale: 1, rotation: 0 });
+        const padding = 32;
+        const gap = 16;
+        const containerWidth = containerRef.current.clientWidth - padding;
+        const containerHeight = containerRef.current.clientHeight - padding;
+        const availableWidth = viewMode === "dual" ? (containerWidth - gap) / 2 : containerWidth;
+        if (zoomMode === "fit-width") {
+          const scale = availableWidth / viewport.width;
+          _setZoomLevel(scale);
+        } else if (zoomMode === "fit-page") {
+          const scaleW = availableWidth / viewport.width;
+          const scaleH = containerHeight / viewport.height;
+          _setZoomLevel(Math.min(scaleW, scaleH));
+        }
+      });
+    };
+    computeFitZoom();
+    const resizeObserver = new ResizeObserver(() => {
+      computeFitZoom();
+    });
+    resizeObserver.observe(containerRef.current);
+    return () => resizeObserver.disconnect();
+  }, [zoomMode, pdfDoc, _setZoomLevel, viewMode]);
+  const isDraggingRef = useRef8(false);
+  const dragStartRef = useRef8({ x: 0, y: 0, scrollLeft: 0, scrollTop: 0 });
+  const handleMouseDown = useCallback7((e) => {
+    if (cursorMode !== "hand") return;
+    const container = containerRef.current;
+    if (!container) return;
+    isDraggingRef.current = true;
+    dragStartRef.current = {
+      x: e.clientX,
+      y: e.clientY,
+      scrollLeft: container.scrollLeft,
+      scrollTop: container.scrollTop
+    };
+    container.style.cursor = "grabbing";
+    e.preventDefault();
+  }, [cursorMode]);
+  useEffect8(() => {
+    if (cursorMode !== "hand") return;
+    const container = containerRef.current;
+    if (!container) return;
+    const handleMouseMove = (e) => {
+      if (!isDraggingRef.current) return;
+      const dx = e.clientX - dragStartRef.current.x;
+      const dy = e.clientY - dragStartRef.current.y;
+      container.scrollLeft = dragStartRef.current.scrollLeft - dx;
+      container.scrollTop = dragStartRef.current.scrollTop - dy;
+    };
+    const handleMouseUp = () => {
+      isDraggingRef.current = false;
+      container.style.cursor = "";
+    };
+    container.addEventListener("mousemove", handleMouseMove);
+    container.addEventListener("mouseup", handleMouseUp);
+    container.addEventListener("mouseleave", handleMouseUp);
+    return () => {
+      container.removeEventListener("mousemove", handleMouseMove);
+      container.removeEventListener("mouseup", handleMouseUp);
+      container.removeEventListener("mouseleave", handleMouseUp);
+    };
+  }, [cursorMode]);
+  const touchStateRef = useRef8(null);
+  const zoomLevelRef = useRef8(zoomLevel);
+  zoomLevelRef.current = zoomLevel;
+  useEffect8(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const getDistance = (t1, t2) => Math.hypot(t2.clientX - t1.clientX, t2.clientY - t1.clientY);
+    const getMidpoint = (t1, t2) => ({
+      x: (t1.clientX + t2.clientX) / 2,
+      y: (t1.clientY + t2.clientY) / 2
+    });
+    const handleTouchStart = (e) => {
+      if (e.touches.length === 2) {
+        e.preventDefault();
+        const dist = getDistance(e.touches[0], e.touches[1]);
+        const mid = getMidpoint(e.touches[0], e.touches[1]);
+        const rect = container.getBoundingClientRect();
+        touchStateRef.current = {
+          startDistance: dist,
+          startZoom: zoomLevelRef.current,
+          startX: 0,
+          startY: 0,
+          startTime: 0,
+          isPinching: true,
+          lastScale: zoomLevelRef.current,
+          centerX: mid.x - rect.left,
+          centerY: mid.y - rect.top,
+          scrollLeft: container.scrollLeft,
+          scrollTop: container.scrollTop
+        };
+      } else if (e.touches.length === 1) {
+        touchStateRef.current = {
+          startDistance: 0,
+          startZoom: zoomLevelRef.current,
+          startX: e.touches[0].clientX,
+          startY: e.touches[0].clientY,
+          startTime: Date.now(),
+          isPinching: false,
+          lastScale: zoomLevelRef.current,
+          centerX: 0,
+          centerY: 0,
+          scrollLeft: 0,
+          scrollTop: 0
+        };
+      }
+    };
+    const handleTouchMove = (e) => {
+      if (!touchStateRef.current) return;
+      if (e.touches.length === 2 && touchStateRef.current.isPinching) {
+        e.preventDefault();
+        const dist = getDistance(e.touches[0], e.touches[1]);
+        const scale = dist / touchStateRef.current.startDistance;
+        const clamped = Math.max(0.25, Math.min(4, touchStateRef.current.startZoom * scale));
+        const visualScale = clamped / touchStateRef.current.startZoom;
+        touchStateRef.current.lastScale = clamped;
+        container.style.transformOrigin = `${touchStateRef.current.centerX}px ${touchStateRef.current.centerY}px`;
+        container.style.transform = `scale(${visualScale})`;
+      }
+    };
+    const handleTouchEnd = (e) => {
+      if (!touchStateRef.current) return;
+      if (touchStateRef.current.isPinching) {
+        const { startZoom, lastScale, centerX, centerY, scrollLeft, scrollTop } = touchStateRef.current;
+        container.style.transform = "";
+        container.style.transformOrigin = "";
+        touchStateRef.current = null;
+        const zoomRatio = lastScale / startZoom;
+        const contentX = scrollLeft + centerX;
+        const contentY = scrollTop + centerY;
+        const newScrollLeft = contentX * zoomRatio - centerX;
+        const newScrollTop = contentY * zoomRatio - centerY;
+        navigatingRef.current = true;
+        zoomTo(lastScale);
+        requestAnimationFrame(() => {
+          requestAnimationFrame(() => {
+            container.scrollLeft = Math.max(0, newScrollLeft);
+            container.scrollTop = Math.max(0, newScrollTop);
+            navigatingRef.current = false;
+          });
+        });
+        return;
+      }
+      touchStateRef.current = null;
+    };
+    container.addEventListener("touchstart", handleTouchStart, { passive: false });
+    container.addEventListener("touchmove", handleTouchMove, { passive: false });
+    container.addEventListener("touchend", handleTouchEnd);
+    return () => {
+      container.removeEventListener("touchstart", handleTouchStart);
+      container.removeEventListener("touchmove", handleTouchMove);
+      container.removeEventListener("touchend", handleTouchEnd);
+    };
+  }, [zoomTo, scrollMode]);
+  const isPageScroll = scrollMode === "page";
+  const shouldRenderPage = (pageNum) => {
+    if (isPrinting) return true;
+    if (isPageScroll) {
+      return Math.abs(pageNum - currentPage) <= VIRTUALIZATION_BUFFER;
+    }
+    void renderGeneration;
+    return lastRenderSetRef.current.has(pageNum);
+  };
+  const classNames = [
+    "pdf-viewer__pages",
+    `pdf-viewer__pages--scroll-${scrollMode}`,
+    viewMode === "dual" && "pdf-viewer__pages--dual",
+    cursorMode === "hand" && "pdf-viewer__pages--hand",
+    className
+  ].filter(Boolean).join(" ");
+  const renderPageWrapper = (pageNum) => {
+    const isActive = isPageScroll && pageNum === currentPage;
+    const wrapperClass = [
+      "pdf-viewer__page-wrapper",
+      isActive && "pdf-viewer__page-wrapper--active"
+    ].filter(Boolean).join(" ");
+    return /* @__PURE__ */ jsx18(
+      "div",
+      {
+        className: wrapperClass,
+        "data-page-number": pageNum,
+        children: shouldRenderPage(pageNum) ? /* @__PURE__ */ jsx18(Page, { pageNumber: pageNum }) : /* @__PURE__ */ jsx18(
+          "div",
+          {
+            className: "pdf-viewer__page-placeholder",
+            style: baseDims ? {
+              width: `${baseDims.width * zoomLevel}px`,
+              height: `${baseDims.height * zoomLevel}px`
+            } : void 0
+          }
+        )
+      },
+      pageNum
+    );
+  };
+  const renderContent = () => {
+    const pages = Array.from({ length: totalPages }, (_, i) => i + 1);
+    if (viewMode === "dual") {
+      const pairs = [];
+      for (let i = 0; i < pages.length; i += 2) {
+        pairs.push(pages.slice(i, i + 2));
+      }
+      return pairs.map((pair) => {
+        const isActive = isPageScroll && pair.includes(currentPage);
+        const pairClass = [
+          "pdf-viewer__page-pair",
+          isActive && "pdf-viewer__page-pair--active"
+        ].filter(Boolean).join(" ");
+        return /* @__PURE__ */ jsx18("div", { className: pairClass, children: pair.map(renderPageWrapper) }, pair[0]);
+      });
+    }
+    return pages.map(renderPageWrapper);
+  };
+  return /* @__PURE__ */ jsx18("div", { ref: containerRef, className: classNames, onMouseDown: handleMouseDown, children: renderContent() });
+}
+
+// src/components/MoreMenu.tsx
+import { jsx as jsx19, jsxs as jsxs8 } from "react/jsx-runtime";
+function MoreMenu({ className }) {
+  const {
+    currentPage,
+    totalPages,
+    rotate,
+    viewMode,
+    scrollMode,
+    setViewMode,
+    setScrollMode,
+    goToFirstPage,
+    goToLastPage,
+    openDocProperties,
+    download,
+    print,
+    toggleFullScreen
+  } = usePdfViewerContext();
+  return /* @__PURE__ */ jsxs8(DropdownMenu, { trigger: /* @__PURE__ */ jsx19(EllipsisVertical, {}), className, align: "right", children: [
+    /* @__PURE__ */ jsxs8("div", { className: "pdf-viewer__show-mobile", children: [
+      /* @__PURE__ */ jsx19(
+        DropdownMenuItem,
+        {
+          icon: /* @__PURE__ */ jsx19(Download, {}),
+          label: "Download",
+          onClick: () => download()
+        }
+      ),
+      /* @__PURE__ */ jsx19(
+        DropdownMenuItem,
+        {
+          icon: /* @__PURE__ */ jsx19(Printer, {}),
+          label: "Print",
+          onClick: print
+        }
+      ),
+      /* @__PURE__ */ jsx19(
+        DropdownMenuItem,
+        {
+          icon: /* @__PURE__ */ jsx19(Maximize, {}),
+          label: "Full Screen",
+          onClick: toggleFullScreen
+        }
+      ),
+      /* @__PURE__ */ jsx19(DropdownMenuSeparator, {})
+    ] }),
+    /* @__PURE__ */ jsx19(
+      DropdownMenuItem,
+      {
+        icon: /* @__PURE__ */ jsx19(ArrowDownToLine, { style: { transform: "rotate(180deg)" } }),
+        label: "First Page",
+        onClick: goToFirstPage,
+        disabled: currentPage <= 1
+      }
+    ),
+    /* @__PURE__ */ jsx19(
+      DropdownMenuItem,
+      {
+        icon: /* @__PURE__ */ jsx19(ArrowDownToLine, {}),
+        label: "Last Page",
+        onClick: goToLastPage,
+        disabled: currentPage >= totalPages
+      }
+    ),
+    /* @__PURE__ */ jsx19(DropdownMenuSeparator, {}),
+    /* @__PURE__ */ jsx19(
+      DropdownMenuItem,
+      {
+        icon: /* @__PURE__ */ jsx19(RotateCw, {}),
+        label: "Rotate Clockwise",
+        onClick: () => rotate(90)
+      }
+    ),
+    /* @__PURE__ */ jsx19(
+      DropdownMenuItem,
+      {
+        icon: /* @__PURE__ */ jsx19(RotateCcw, {}),
+        label: "Rotate Counterclockwise",
+        onClick: () => rotate(-90)
+      }
+    ),
+    /* @__PURE__ */ jsx19(DropdownMenuSeparator, {}),
+    /* @__PURE__ */ jsx19(
+      DropdownMenuItem,
+      {
+        icon: /* @__PURE__ */ jsx19(StickyNote, {}),
+        label: "Single Page",
+        onClick: () => setViewMode("single"),
+        active: viewMode === "single"
+      }
+    ),
+    /* @__PURE__ */ jsx19(
+      DropdownMenuItem,
+      {
+        icon: /* @__PURE__ */ jsx19(Columns2, {}),
+        label: "Dual Page",
+        onClick: () => setViewMode("dual"),
+        active: viewMode === "dual",
+        disabled: scrollMode === "horizontal"
+      }
+    ),
+    /* @__PURE__ */ jsx19(DropdownMenuSeparator, {}),
+    /* @__PURE__ */ jsx19(
+      DropdownMenuItem,
+      {
+        icon: /* @__PURE__ */ jsx19(GalleryThumbnails, {}),
+        label: "Page Scrolling",
+        onClick: () => setScrollMode("page"),
+        active: scrollMode === "page"
+      }
+    ),
+    /* @__PURE__ */ jsx19(
+      DropdownMenuItem,
+      {
+        icon: /* @__PURE__ */ jsx19(GalleryVertical, {}),
+        label: "Vertical Scrolling",
+        onClick: () => setScrollMode("vertical"),
+        active: scrollMode === "vertical"
+      }
+    ),
+    /* @__PURE__ */ jsx19(
+      DropdownMenuItem,
+      {
+        icon: /* @__PURE__ */ jsx19(GalleryHorizontal, {}),
+        label: "Horizontal Scrolling",
+        onClick: () => setScrollMode("horizontal"),
+        active: scrollMode === "horizontal",
+        disabled: viewMode === "dual"
+      }
+    ),
+    /* @__PURE__ */ jsx19(DropdownMenuSeparator, {}),
+    /* @__PURE__ */ jsx19(
+      DropdownMenuItem,
+      {
+        icon: /* @__PURE__ */ jsx19(Info, {}),
+        label: "Document Properties",
+        onClick: openDocProperties
+      }
+    )
+  ] });
+}
+
+// src/components/DocumentPropertiesModal.tsx
+import { useEffect as useEffect9, useRef as useRef9 } from "react";
+import { jsx as jsx20, jsxs as jsxs9 } from "react/jsx-runtime";
+function DocumentPropertiesModal() {
+  const { isDocPropertiesOpen, docProperties, closeDocProperties } = usePdfViewerContext();
+  const backdropRef = useRef9(null);
+  useEffect9(() => {
+    if (!isDocPropertiesOpen) return;
+    const handleEscape = (e) => {
+      if (e.key === "Escape") closeDocProperties();
+    };
+    window.document.addEventListener("keydown", handleEscape);
+    return () => window.document.removeEventListener("keydown", handleEscape);
+  }, [isDocPropertiesOpen, closeDocProperties]);
+  if (!isDocPropertiesOpen || !docProperties) return null;
+  const rows = [
+    ["Title", docProperties.title],
+    ["Author", docProperties.author],
+    ["Subject", docProperties.subject],
+    ["Creator", docProperties.creator],
+    ["Producer", docProperties.producer],
+    ["Created", docProperties.creationDate],
+    ["Modified", docProperties.modificationDate],
+    ["Pages", String(docProperties.pageCount)],
+    ["Page Size", docProperties.pageSize]
+  ];
+  return /* @__PURE__ */ jsx20(
+    "div",
+    {
+      ref: backdropRef,
+      className: "pdf-viewer__modal-backdrop",
+      onClick: (e) => {
+        if (e.target === backdropRef.current) closeDocProperties();
+      },
+      children: /* @__PURE__ */ jsxs9("div", { className: "pdf-viewer__modal", role: "dialog", "aria-label": "Document Properties", children: [
+        /* @__PURE__ */ jsxs9("div", { className: "pdf-viewer__modal-header", children: [
+          /* @__PURE__ */ jsx20("h2", { className: "pdf-viewer__modal-title", children: "Document Properties" }),
+          /* @__PURE__ */ jsx20("button", { className: "pdf-viewer__btn", onClick: closeDocProperties, "aria-label": "Close", title: "Close", children: /* @__PURE__ */ jsx20(X, {}) })
+        ] }),
+        /* @__PURE__ */ jsxs9("div", { className: "pdf-viewer__modal-body", children: [
+          /* @__PURE__ */ jsxs9("div", { className: "pdf-viewer__props-file-info", children: [
+            /* @__PURE__ */ jsx20("span", { className: "pdf-viewer__props-file-name", children: docProperties.fileName }),
+            /* @__PURE__ */ jsx20("span", { className: "pdf-viewer__props-file-size", children: docProperties.fileSize })
+          ] }),
+          /* @__PURE__ */ jsx20("table", { className: "pdf-viewer__props-table", children: /* @__PURE__ */ jsx20("tbody", { children: rows.map(([label, value]) => /* @__PURE__ */ jsxs9("tr", { children: [
+            /* @__PURE__ */ jsx20("td", { className: "pdf-viewer__props-label", children: label }),
+            /* @__PURE__ */ jsx20("td", { className: "pdf-viewer__props-value", children: value })
+          ] }, label)) }) })
+        ] })
+      ] })
+    }
+  );
+}
+
+// src/components/PdfViewer.tsx
+import { jsx as jsx21, jsxs as jsxs10 } from "react/jsx-runtime";
+function PdfViewer(props) {
+  const { className, ...rootProps } = props;
+  return /* @__PURE__ */ jsxs10(Root, { className, ...rootProps, children: [
+    /* @__PURE__ */ jsxs10(Toolbar, { children: [
+      /* @__PURE__ */ jsx21(Navigation, {}),
+      /* @__PURE__ */ jsx21(Separator, {}),
+      /* @__PURE__ */ jsx21(Zoom, {}),
+      /* @__PURE__ */ jsx21(ThumbnailToggle, {}),
+      /* @__PURE__ */ jsxs10("div", { className: "pdf-viewer__toolbar-extras", children: [
+        /* @__PURE__ */ jsx21(Separator, {}),
+        /* @__PURE__ */ jsx21(Search, {}),
+        /* @__PURE__ */ jsx21(Separator, {}),
+        /* @__PURE__ */ jsx21(Rotate, {}),
+        /* @__PURE__ */ jsx21(Download2, {}),
+        /* @__PURE__ */ jsx21(Print, {}),
+        /* @__PURE__ */ jsx21(FullScreen, {}),
+        /* @__PURE__ */ jsx21(CursorModeToggle, {})
+      ] }),
+      /* @__PURE__ */ jsx21(MoreMenu, {})
+    ] }),
+    /* @__PURE__ */ jsxs10("div", { className: "pdf-viewer__body", children: [
+      /* @__PURE__ */ jsx21(ThumbnailSidebar, {}),
+      /* @__PURE__ */ jsx21(Pages, {})
+    ] }),
+    /* @__PURE__ */ jsx21(DocumentPropertiesModal, {})
+  ] });
+}
+PdfViewer.Root = Root;
+PdfViewer.Toolbar = Toolbar;
+PdfViewer.Navigation = Navigation;
+PdfViewer.Zoom = Zoom;
+PdfViewer.Search = Search;
+PdfViewer.Separator = Separator;
+PdfViewer.Rotate = Rotate;
+PdfViewer.Download = Download2;
+PdfViewer.Print = Print;
+PdfViewer.FullScreen = FullScreen;
+PdfViewer.ThumbnailToggle = ThumbnailToggle;
+PdfViewer.ThumbnailSidebar = ThumbnailSidebar;
+PdfViewer.Pages = Pages;
+PdfViewer.Page = Page;
+PdfViewer.CursorModeToggle = CursorModeToggle;
+PdfViewer.MoreMenu = MoreMenu;
+PdfViewer.DropdownMenu = DropdownMenu;
+PdfViewer.DropdownMenuItem = DropdownMenuItem;
+PdfViewer.DropdownMenuSeparator = DropdownMenuSeparator;
+PdfViewer.DocumentPropertiesModal = DocumentPropertiesModal;
+
+// src/hooks/use-pdf-viewer.ts
+function usePdfViewer() {
+  return usePdfViewerContext();
+}
+export {
+  CursorModeToggle,
+  DocumentPropertiesModal,
+  Download2 as Download,
+  DropdownMenu,
+  DropdownMenuItem,
+  DropdownMenuSeparator,
+  FullScreen,
+  MoreMenu,
+  Navigation,
+  Page,
+  Pages,
+  PdfViewer,
+  Print,
+  Root,
+  Rotate,
+  Search,
+  Separator,
+  ThumbnailSidebar,
+  ThumbnailToggle,
+  Toolbar,
+  Zoom,
+  usePdfViewer
+};
+//# sourceMappingURL=index.js.map