@cannyminds/dms-file-viewers 0.13.0 → 0.15.0

package/dist/chunk-TMAHQICY.mjs

@@ -0,0 +1,1842 @@
+"use client";
+import {
+  toolbarStyles
+} from "./chunk-GMDRDOWP.mjs";
+import {
+  getFileExtension
+} from "./chunk-M57PSU4O.mjs";
+import {
+  FileIcon_default,
+  mergeToolbarConfig
+} from "./chunk-WR5SJ3LM.mjs";
+
+// src/components/viewers/PDFViewer.tsx
+import {
+  useCallback,
+  useEffect as useEffect3,
+  useMemo,
+  useRef as useRef2,
+  useState as useState3,
+  forwardRef,
+  useImperativeHandle
+} from "react";
+
+// src/components/viewers/pdf/StablePDFViewer.tsx
+import React from "react";
+import { PDFViewer as HeadlessPDFViewerImport } from "@cannyminds/pdf-viewer";
+import { jsx } from "react/jsx-runtime";
+var HeadlessPDFViewer = HeadlessPDFViewerImport;
+var StablePDFViewer = React.memo(({
+  pdfBuffer,
+  onPasswordRequest,
+  pdfViewerRef
+}) => {
+  return /* @__PURE__ */ jsx(
+    HeadlessPDFViewer,
+    {
+      ref: pdfViewerRef,
+      pdfBuffer,
+      onPasswordRequest
+    }
+  );
+});
+StablePDFViewer.displayName = "StablePDFViewer";
+
+// src/components/viewers/pdf/PDFToolbar.tsx
+import React2 from "react";
+import FirstPageIcon from "@mui/icons-material/FirstPage";
+import LastPageIcon from "@mui/icons-material/LastPage";
+import ChevronLeftIcon from "@mui/icons-material/ChevronLeft";
+import ChevronRightIcon from "@mui/icons-material/ChevronRight";
+import ZoomInIcon from "@mui/icons-material/ZoomIn";
+import ZoomOutIcon from "@mui/icons-material/ZoomOut";
+import FitScreenIcon from "@mui/icons-material/FitScreen";
+import AspectRatioIcon from "@mui/icons-material/AspectRatio";
+import SearchIcon from "@mui/icons-material/Search";
+import FullscreenIcon from "@mui/icons-material/Fullscreen";
+import DownloadIcon from "@mui/icons-material/Download";
+import PrintIcon from "@mui/icons-material/Print";
+import InfoIcon from "@mui/icons-material/Info";
+import DescriptionIcon from "@mui/icons-material/Description";
+import RotateLeftIcon from "@mui/icons-material/RotateLeft";
+import RotateRightIcon from "@mui/icons-material/RotateRight";
+import { LocalOffer } from "@mui/icons-material";
+import { Fragment, jsx as jsx2, jsxs } from "react/jsx-runtime";
+var PDFToolbar = React2.memo(
+  ({
+    currentPage,
+    totalPages,
+    zoom,
+    isSidebarOpen,
+    showPageNavigation,
+    showPageCount,
+    showZoomControls,
+    showSearch,
+    showMetadata,
+    showProperties,
+    showTags,
+    showDownload,
+    showPrint,
+    showRotation,
+    disabledRotateLeft,
+    disabledRotateRight,
+    disabledMetadata,
+    disabledProperties,
+    disabledTags,
+    disabledDownload,
+    disabledPrint,
+    onFirstPage,
+    onPreviousPage,
+    onNextPage,
+    onLastPage,
+    onPageInput,
+    onPageInputKeyPress,
+    onZoomIn,
+    onZoomOut,
+    onFitToWidth,
+    onFitToPage,
+    onToggleSidebar,
+    onToggleFullScreen,
+    onRotateLeft,
+    onRotateRight,
+    onDownloadClick,
+    onPrintClick,
+    onMetadataClick,
+    onPropertiesClick,
+    onTagsClick
+  }) => {
+    return /* @__PURE__ */ jsxs("div", { className: "pdf-viewer-toolbar", children: [
+      showPageNavigation && /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx2("div", { className: "toolbar-separator" }),
+        /* @__PURE__ */ jsxs("div", { className: "toolbar-section", children: [
+          /* @__PURE__ */ jsx2(
+            "button",
+            {
+              className: "toolbar-button",
+              onClick: onFirstPage,
+              disabled: currentPage <= 1,
+              title: "First Page",
+              children: /* @__PURE__ */ jsx2(FirstPageIcon, { fontSize: "small" })
+            }
+          ),
+          /* @__PURE__ */ jsx2(
+            "button",
+            {
+              className: "toolbar-button",
+              onClick: onPreviousPage,
+              disabled: currentPage <= 1,
+              title: "Previous Page",
+              children: /* @__PURE__ */ jsx2(ChevronLeftIcon, { fontSize: "small" })
+            }
+          ),
+          /* @__PURE__ */ jsx2(
+            "input",
+            {
+              type: "number",
+              className: "page-input",
+              value: currentPage,
+              onChange: onPageInput,
+              onKeyPress: onPageInputKeyPress,
+              min: 1,
+              max: totalPages || void 0
+            }
+          ),
+          showPageCount && /* @__PURE__ */ jsxs("span", { className: "page-info", children: [
+            "of ",
+            totalPages || "..."
+          ] }),
+          /* @__PURE__ */ jsx2(
+            "button",
+            {
+              className: "toolbar-button",
+              onClick: onNextPage,
+              disabled: currentPage >= totalPages,
+              title: "Next Page",
+              children: /* @__PURE__ */ jsx2(ChevronRightIcon, { fontSize: "small" })
+            }
+          ),
+          /* @__PURE__ */ jsx2(
+            "button",
+            {
+              className: "toolbar-button",
+              onClick: onLastPage,
+              disabled: currentPage >= totalPages,
+              title: "Last Page",
+              children: /* @__PURE__ */ jsx2(LastPageIcon, { fontSize: "small" })
+            }
+          )
+        ] })
+      ] }),
+      showZoomControls && /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx2("div", { className: "toolbar-separator" }),
+        /* @__PURE__ */ jsxs("div", { className: "toolbar-section", children: [
+          /* @__PURE__ */ jsx2(
+            "button",
+            {
+              className: "toolbar-button",
+              onClick: onZoomOut,
+              title: "Zoom Out",
+              children: /* @__PURE__ */ jsx2(ZoomOutIcon, { fontSize: "small" })
+            }
+          ),
+          /* @__PURE__ */ jsxs("span", { className: "zoom-display", children: [
+            zoom,
+            "%"
+          ] }),
+          /* @__PURE__ */ jsx2(
+            "button",
+            {
+              className: "toolbar-button",
+              onClick: onZoomIn,
+              title: "Zoom In",
+              children: /* @__PURE__ */ jsx2(ZoomInIcon, { fontSize: "small" })
+            }
+          ),
+          /* @__PURE__ */ jsx2(
+            "button",
+            {
+              className: "toolbar-button",
+              onClick: onFitToWidth,
+              title: "Fit to Width",
+              children: /* @__PURE__ */ jsx2(AspectRatioIcon, { fontSize: "small" })
+            }
+          ),
+          /* @__PURE__ */ jsx2(
+            "button",
+            {
+              className: "toolbar-button",
+              onClick: onFitToPage,
+              title: "Fit to Page",
+              children: /* @__PURE__ */ jsx2(FitScreenIcon, { fontSize: "small" })
+            }
+          )
+        ] })
+      ] }),
+      showRotation && /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx2("div", { className: "toolbar-separator" }),
+        /* @__PURE__ */ jsxs("div", { className: "toolbar-section", children: [
+          /* @__PURE__ */ jsx2(
+            "button",
+            {
+              className: "toolbar-button",
+              onClick: onRotateLeft,
+              disabled: disabledRotateLeft,
+              title: "Rotate Counterclockwise",
+              children: /* @__PURE__ */ jsx2(RotateLeftIcon, { fontSize: "small" })
+            }
+          ),
+          /* @__PURE__ */ jsx2(
+            "button",
+            {
+              className: "toolbar-button",
+              onClick: onRotateRight,
+              disabled: disabledRotateRight,
+              title: "Rotate Clockwise",
+              children: /* @__PURE__ */ jsx2(RotateRightIcon, { fontSize: "small" })
+            }
+          )
+        ] })
+      ] }),
+      showSearch && /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx2("div", { className: "toolbar-separator" }),
+        /* @__PURE__ */ jsx2("div", { className: "toolbar-section", children: /* @__PURE__ */ jsx2(
+          "button",
+          {
+            className: "toolbar-button",
+            onClick: onToggleSidebar,
+            title: "Search in PDF",
+            style: {
+              backgroundColor: isSidebarOpen ? "#e3f2fd" : "transparent",
+              color: isSidebarOpen ? "#1976d2" : "inherit"
+            },
+            children: /* @__PURE__ */ jsx2(SearchIcon, { fontSize: "small" })
+          }
+        ) })
+      ] }),
+      /* @__PURE__ */ jsx2("div", { className: "toolbar-separator" }),
+      /* @__PURE__ */ jsx2("div", { className: "toolbar-section", children: /* @__PURE__ */ jsx2(
+        "button",
+        {
+          className: "toolbar-button",
+          onClick: onToggleFullScreen,
+          title: "Fullscreen",
+          children: /* @__PURE__ */ jsx2(FullscreenIcon, { fontSize: "small" })
+        }
+      ) }),
+      (showMetadata || showProperties || showDownload || showPrint || showTags) && /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx2("div", { className: "toolbar-separator" }),
+        /* @__PURE__ */ jsxs("div", { className: "toolbar-section", children: [
+          showDownload && /* @__PURE__ */ jsx2(
+            "button",
+            {
+              className: "toolbar-button",
+              onClick: onDownloadClick,
+              disabled: disabledDownload,
+              title: "Download PDF",
+              children: /* @__PURE__ */ jsx2(DownloadIcon, { fontSize: "small" })
+            }
+          ),
+          showPrint && /* @__PURE__ */ jsx2(
+            "button",
+            {
+              className: "toolbar-button",
+              onClick: onPrintClick,
+              disabled: disabledPrint,
+              title: "Print PDF",
+              children: /* @__PURE__ */ jsx2(PrintIcon, { fontSize: "small" })
+            }
+          ),
+          showMetadata && /* @__PURE__ */ jsx2(
+            "button",
+            {
+              className: "toolbar-button",
+              onClick: onMetadataClick,
+              disabled: disabledMetadata,
+              title: "Document Metadata",
+              children: /* @__PURE__ */ jsx2(DescriptionIcon, { fontSize: "small" })
+            }
+          ),
+          showProperties && /* @__PURE__ */ jsx2(
+            "button",
+            {
+              className: "toolbar-button",
+              onClick: onPropertiesClick,
+              disabled: disabledProperties,
+              title: "Document Properties",
+              children: /* @__PURE__ */ jsx2(InfoIcon, { fontSize: "small" })
+            }
+          ),
+          showTags && /* @__PURE__ */ jsx2(
+            "button",
+            {
+              className: "toolbar-button",
+              onClick: onTagsClick,
+              disabled: disabledTags,
+              title: "Document Tags",
+              children: /* @__PURE__ */ jsx2(LocalOffer, { fontSize: "small" })
+            }
+          )
+        ] })
+      ] })
+    ] });
+  }
+);
+PDFToolbar.displayName = "PDFToolbar";
+
+// src/components/viewers/pdf/PDFHeader.tsx
+import React3 from "react";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var PDFHeader = React3.memo(({ fileName, fileExtension }) => {
+  return /* @__PURE__ */ jsxs2("div", { className: "pdf-viewer-header", children: [
+    /* @__PURE__ */ jsx3(FileIcon_default, { ext: fileExtension, size: 26 }),
+    /* @__PURE__ */ jsx3("div", { className: "header-file-name", title: fileName, children: fileName })
+  ] });
+});
+PDFHeader.displayName = "PDFHeader";
+
+// src/components/viewers/pdf/SearchSidebar.tsx
+import { useState, useLayoutEffect, useEffect, useRef } from "react";
+import {
+  Box,
+  Typography,
+  TextField,
+  IconButton,
+  InputAdornment,
+  Divider,
+  CircularProgress
+} from "@mui/material";
+import SearchIcon2 from "@mui/icons-material/Search";
+import CloseIcon from "@mui/icons-material/Close";
+import KeyboardArrowUpIcon from "@mui/icons-material/KeyboardArrowUp";
+import KeyboardArrowDownIcon from "@mui/icons-material/KeyboardArrowDown";
+import ClearIcon from "@mui/icons-material/Clear";
+import FindInPageIcon from "@mui/icons-material/FindInPage";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var SearchSidebar = ({
+  isOpen,
+  onClose,
+  onSearch,
+  onSearchResultClick,
+  onNextResult,
+  onPreviousResult,
+  currentResultIndex,
+  totalResults,
+  searchKeyword,
+  searchResults = [],
+  isSearching = false,
+  isSyntheticResults = false
+}) => {
+  const [searchTerm, setSearchTerm] = useState(searchKeyword || "");
+  const [hasSearched, setHasSearched] = useState(false);
+  const contentRef = useRef(null);
+  useEffect(() => {
+    if (searchKeyword && searchKeyword !== searchTerm) {
+      setSearchTerm(searchKeyword);
+    }
+  }, [searchKeyword]);
+  useLayoutEffect(() => {
+    const element = contentRef.current;
+    if (!element) return;
+    const handleMouseMove = (e) => {
+      const rect = element.getBoundingClientRect();
+      const distanceFromRight = rect.right - e.clientX;
+      const distanceFromBottom = rect.bottom - e.clientY;
+      if (distanceFromRight <= 15 || distanceFromBottom <= 15) {
+        element.classList.add("scrollbar-hover");
+      } else {
+        element.classList.remove("scrollbar-hover");
+      }
+    };
+    const handleMouseLeave = () => element.classList.remove("scrollbar-hover");
+    element.addEventListener("mousemove", handleMouseMove);
+    element.addEventListener("mouseleave", handleMouseLeave);
+    return () => {
+      element.removeEventListener("mousemove", handleMouseMove);
+      element.removeEventListener("mouseleave", handleMouseLeave);
+    };
+  }, []);
+  useLayoutEffect(() => {
+    const style = document.createElement("style");
+    style.id = "search-sidebar-scrollbar";
+    style.textContent = `
+      @import url('https://fonts.googleapis.com/css2?family=Noto+Sans+Tamil:wght@400;600&family=Noto+Sans+Devanagari:wght@400;600&display=swap');
+      
+      .search-sidebar-content::-webkit-scrollbar {
+        width: 12px;
+        height: 12px;
+      }
+      .search-sidebar-content::-webkit-scrollbar-track {
+        background-color: transparent;
+      }
+      .search-sidebar-content::-webkit-scrollbar-thumb {
+        background-color: rgba(128, 128, 128, 0.3);
+        border-radius: 8px;
+        border: 4px solid transparent;
+        background-clip: padding-box;
+        transition: all 0.15s ease;
+      }
+      .search-sidebar-content.scrollbar-hover::-webkit-scrollbar-thumb {
+        background-color: rgba(128, 128, 128, 0.5);
+        border: 2px solid transparent;
+      }
+      .search-sidebar-content::-webkit-scrollbar-thumb:active {
+        background-color: rgba(25, 118, 210, 0.8);
+        border: 1px solid transparent;
+      }
+
+      @media (prefers-color-scheme: dark) {
+        .search-sidebar-content::-webkit-scrollbar-thumb {
+          background-color: rgba(255, 255, 255, 0.2);
+        }
+        .search-sidebar-content.scrollbar-hover::-webkit-scrollbar-thumb {
+          background-color: rgba(255, 255, 255, 0.35);
+        }
+      }
+      
+      /* Tamil font support for search results */
+      .search-result-text {
+        font-family: 'Noto Sans Tamil', 'Noto Sans Devanagari', Arial, sans-serif !important;
+      }
+    `;
+    document.head.appendChild(style);
+    return () => {
+      const el = document.getElementById("search-sidebar-scrollbar");
+      if (el) el.remove();
+    };
+  }, []);
+  useLayoutEffect(() => {
+    setSearchTerm(searchKeyword || "");
+    if (searchKeyword || searchResults.length > 0) {
+      setHasSearched(true);
+    }
+  }, [searchKeyword, searchResults]);
+  const handleSearchSubmit = (e) => {
+    if (e) e.preventDefault();
+    if (searchTerm.trim()) {
+      setHasSearched(true);
+      onSearch(searchTerm.trim());
+    }
+  };
+  const handleSearchChange = (e) => {
+    const value = e.target.value;
+    setSearchTerm(value);
+    if (!value.trim()) {
+      setHasSearched(false);
+      onSearch("");
+    }
+  };
+  const handleClearSearch = () => {
+    setSearchTerm("");
+    setHasSearched(false);
+    onSearch("");
+  };
+  const resultsByPage = searchResults.reduce((acc, result) => {
+    if (!acc[result.pageNumber]) {
+      acc[result.pageNumber] = [];
+    }
+    acc[result.pageNumber].push(result);
+    return acc;
+  }, {});
+  const highlightText = (text, keyword) => {
+    if (!keyword) return text;
+    const textString = typeof text === "string" ? text : String(text || "");
+    if (!textString) return text;
+    try {
+      const escapedKeyword = keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const regex = new RegExp(`(${escapedKeyword})`, "gi");
+      const parts = textString.split(regex);
+      return parts.map(
+        (part, index) => regex.test(part) ? /* @__PURE__ */ jsx4(
+          Box,
+          {
+            component: "span",
+            sx: {
+              color: "primary.main",
+              fontWeight: 600,
+              fontSize: "inherit"
+            },
+            children: part
+          },
+          index
+        ) : part
+      );
+    } catch (error) {
+      return textString;
+    }
+  };
+  if (!isOpen) return null;
+  return /* @__PURE__ */ jsxs3(
+    Box,
+    {
+      sx: {
+        display: "flex",
+        flexDirection: "column",
+        height: "100%",
+        width: "320px",
+        backgroundColor: "background.paper",
+        borderLeft: "1px solid",
+        borderColor: "divider",
+        overflow: "hidden"
+      },
+      children: [
+        /* @__PURE__ */ jsxs3(Box, { sx: { px: 3, py: 2.5, backgroundColor: "background.default" }, children: [
+          /* @__PURE__ */ jsxs3(Box, { sx: { display: "flex", alignItems: "center", justifyContent: "space-between", mb: 2 }, children: [
+            /* @__PURE__ */ jsx4(Typography, { variant: "h6", sx: { fontSize: "1.125rem", fontWeight: 600, color: "text.primary" }, children: "Search" }),
+            /* @__PURE__ */ jsx4(
+              IconButton,
+              {
+                size: "small",
+                onClick: onClose,
+                sx: {
+                  color: "text.secondary",
+                  padding: "6px"
+                },
+                children: /* @__PURE__ */ jsx4(CloseIcon, { fontSize: "small" })
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx4("form", { onSubmit: handleSearchSubmit, children: /* @__PURE__ */ jsx4(
+            TextField,
+            {
+              fullWidth: true,
+              size: "medium",
+              placeholder: "Search in document...",
+              value: searchTerm,
+              onChange: handleSearchChange,
+              autoComplete: "off",
+              InputProps: {
+                startAdornment: /* @__PURE__ */ jsx4(InputAdornment, { position: "start", children: /* @__PURE__ */ jsx4(SearchIcon2, { sx: { color: "text.disabled", fontSize: 20 } }) }),
+                endAdornment: searchTerm && /* @__PURE__ */ jsx4(InputAdornment, { position: "end", children: /* @__PURE__ */ jsx4(
+                  IconButton,
+                  {
+                    size: "small",
+                    onClick: handleClearSearch,
+                    sx: {
+                      color: "text.secondary",
+                      padding: "4px",
+                      "&:hover": {
+                        backgroundColor: "action.hover"
+                      }
+                    },
+                    children: /* @__PURE__ */ jsx4(ClearIcon, { sx: { fontSize: 18 } })
+                  }
+                ) })
+              },
+              sx: {
+                "& .MuiOutlinedInput-root": {
+                  fontSize: "0.9375rem",
+                  backgroundColor: "background.paper",
+                  borderRadius: "8px",
+                  "& fieldset": {
+                    borderColor: "divider"
+                  },
+                  "&.Mui-focused fieldset": {
+                    borderColor: "primary.main",
+                    borderWidth: "2px"
+                  }
+                },
+                "& .MuiInputBase-input": {
+                  padding: "10px 14px"
+                }
+              }
+            }
+          ) }),
+          totalResults > 0 && /* @__PURE__ */ jsxs3(
+            Box,
+            {
+              sx: {
+                display: "flex",
+                alignItems: "center",
+                justifyContent: "space-between",
+                mt: 2,
+                pt: 2,
+                borderTop: "1px solid",
+                borderColor: "divider"
+              },
+              children: [
+                /* @__PURE__ */ jsxs3(Typography, { variant: "body2", sx: { color: "text.secondary", fontSize: "0.875rem", fontWeight: 500 }, children: [
+                  currentResultIndex + 1,
+                  " of ",
+                  totalResults,
+                  " results"
+                ] }),
+                /* @__PURE__ */ jsxs3(Box, { sx: { display: "flex", alignItems: "center", gap: 0.5 }, children: [
+                  /* @__PURE__ */ jsx4(
+                    IconButton,
+                    {
+                      size: "small",
+                      onClick: onPreviousResult,
+                      disabled: currentResultIndex <= 0,
+                      sx: {
+                        color: currentResultIndex <= 0 ? "text.disabled" : "primary.main",
+                        padding: "6px",
+                        borderRadius: "6px",
+                        border: "1px solid",
+                        borderColor: currentResultIndex <= 0 ? "divider" : "primary.main"
+                      },
+                      children: /* @__PURE__ */ jsx4(KeyboardArrowUpIcon, { sx: { fontSize: 20 } })
+                    }
+                  ),
+                  /* @__PURE__ */ jsx4(
+                    IconButton,
+                    {
+                      size: "small",
+                      onClick: onNextResult,
+                      disabled: currentResultIndex >= totalResults - 1,
+                      sx: {
+                        color: currentResultIndex >= totalResults - 1 ? "text.disabled" : "primary.main",
+                        padding: "6px",
+                        borderRadius: "6px",
+                        border: "1px solid",
+                        borderColor: currentResultIndex >= totalResults - 1 ? "divider" : "primary.main"
+                      },
+                      children: /* @__PURE__ */ jsx4(KeyboardArrowDownIcon, { sx: { fontSize: 20 } })
+                    }
+                  )
+                ] })
+              ]
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx4(Divider, {}),
+        /* @__PURE__ */ jsxs3(Box, { ref: contentRef, className: "search-sidebar-content", sx: {
+          flex: 1,
+          overflow: "auto",
+          backgroundColor: "background.default"
+        }, children: [
+          !searchTerm && !hasSearched && /* @__PURE__ */ jsxs3(Box, { sx: { p: 4, textAlign: "center", mt: 6 }, children: [
+            /* @__PURE__ */ jsx4(
+              Box,
+              {
+                sx: {
+                  width: 80,
+                  height: 80,
+                  borderRadius: "50%",
+                  backgroundColor: "action.hover",
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  margin: "0 auto",
+                  mb: 3
+                },
+                children: /* @__PURE__ */ jsx4(SearchIcon2, { sx: { fontSize: 40, color: "text.disabled" } })
+              }
+            ),
+            /* @__PURE__ */ jsx4(Typography, { variant: "body1", sx: { color: "text.primary", fontWeight: 500, mb: 1 }, children: "Search in Document" }),
+            /* @__PURE__ */ jsx4(Typography, { variant: "body2", sx: { color: "text.secondary", lineHeight: 1.6 }, children: "Enter keywords to find text within the PDF document" })
+          ] }),
+          searchTerm && !hasSearched && !isSearching && /* @__PURE__ */ jsxs3(Box, { sx: { p: 4, textAlign: "center", mt: 6 }, children: [
+            /* @__PURE__ */ jsx4(
+              Box,
+              {
+                sx: {
+                  width: 80,
+                  height: 80,
+                  borderRadius: "50%",
+                  backgroundColor: "primary.light",
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  margin: "0 auto",
+                  mb: 3,
+                  opacity: 0.2
+                },
+                children: /* @__PURE__ */ jsx4(FindInPageIcon, { sx: { fontSize: 40, color: "primary.main" } })
+              }
+            ),
+            /* @__PURE__ */ jsx4(Typography, { variant: "body1", sx: { color: "text.primary", fontWeight: 500, mb: 1 }, children: "Ready to Search" }),
+            /* @__PURE__ */ jsx4(Typography, { variant: "body2", sx: { color: "text.secondary", mb: 2, lineHeight: 1.6 }, children: "Press Enter to find" }),
+            /* @__PURE__ */ jsxs3(
+              Typography,
+              {
+                variant: "body2",
+                sx: {
+                  color: "white",
+                  fontWeight: 600,
+                  backgroundColor: (theme) => theme.palette.mode === "dark" ? "rgba(144, 202, 249, 0.16)" : "primary.light",
+                  padding: "6px 16px",
+                  borderRadius: "16px",
+                  display: "inline-block",
+                  opacity: 0.9
+                },
+                children: [
+                  '"',
+                  searchTerm,
+                  '"'
+                ]
+              }
+            )
+          ] }),
+          isSearching && /* @__PURE__ */ jsxs3(Box, { sx: { p: 4, textAlign: "center", mt: 6 }, children: [
+            /* @__PURE__ */ jsx4(
+              Box,
+              {
+                sx: {
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  margin: "0 auto",
+                  mb: 3
+                },
+                children: /* @__PURE__ */ jsx4(CircularProgress, { size: 60, thickness: 4 })
+              }
+            ),
+            /* @__PURE__ */ jsx4(Typography, { variant: "body1", sx: { color: "text.primary", fontWeight: 500, mb: 1 }, children: "Searching..." }),
+            /* @__PURE__ */ jsxs3(Typography, { variant: "body2", sx: { color: "text.secondary", lineHeight: 1.6 }, children: [
+              'Finding matches for "',
+              searchTerm,
+              '"'
+            ] })
+          ] }),
+          hasSearched && totalResults === 0 && !isSearching && /* @__PURE__ */ jsxs3(Box, { sx: { p: 4, textAlign: "center", mt: 6 }, children: [
+            /* @__PURE__ */ jsx4(
+              Box,
+              {
+                sx: {
+                  width: 80,
+                  height: 80,
+                  borderRadius: "50%",
+                  backgroundColor: (theme) => theme.palette.mode === "dark" ? "rgba(255, 152, 0, 0.12)" : "warning.light",
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  margin: "0 auto",
+                  mb: 3,
+                  opacity: 0.6
+                },
+                children: /* @__PURE__ */ jsx4(SearchIcon2, { sx: { fontSize: 40, color: "warning.main" } })
+              }
+            ),
+            /* @__PURE__ */ jsx4(Typography, { variant: "body1", sx: { color: "text.primary", fontWeight: 500, mb: 1 }, children: "No Results Found" }),
+            /* @__PURE__ */ jsxs3(Typography, { variant: "body2", sx: { color: "text.secondary", lineHeight: 1.6 }, children: [
+              "No matches found for ",
+              /* @__PURE__ */ jsxs3("strong", { children: [
+                '"',
+                searchTerm,
+                '"'
+              ] })
+            ] })
+          ] }),
+          totalResults > 0 && /* @__PURE__ */ jsx4(Box, { sx: { p: 2 }, children: Object.keys(resultsByPage).sort((a, b) => parseInt(a) - parseInt(b)).map((pageNum) => {
+            const pageNumber = parseInt(pageNum);
+            const pageResults = resultsByPage[pageNumber];
+            return /* @__PURE__ */ jsxs3(Box, { sx: { mb: 3 }, children: [
+              /* @__PURE__ */ jsxs3(
+                Typography,
+                {
+                  variant: "subtitle2",
+                  sx: {
+                    color: "text.secondary",
+                    mb: 1.5,
+                    px: 1,
+                    fontSize: "0.8125rem",
+                    fontWeight: 600,
+                    textTransform: "uppercase",
+                    letterSpacing: "0.5px"
+                  },
+                  children: [
+                    "Page ",
+                    pageNumber
+                  ]
+                }
+              ),
+              pageResults.map((result, index) => /* @__PURE__ */ jsx4(
+                Box,
+                {
+                  onClick: () => onSearchResultClick(result.pageNumber, result.index),
+                  sx: {
+                    p: 2,
+                    mx: 1,
+                    mb: 1.5,
+                    borderRadius: "8px",
+                    border: "2px solid",
+                    borderColor: result.index === currentResultIndex ? "primary.main" : "divider",
+                    backgroundColor: "background.paper",
+                    cursor: "pointer",
+                    transition: "all 0.2s ease",
+                    boxShadow: (theme) => theme.palette.mode === "dark" ? "0 1px 3px rgba(0, 0, 0, 0.3)" : "0 1px 3px rgba(0, 0, 0, 0.05)",
+                    "&:hover": {
+                      borderColor: "primary.main",
+                      boxShadow: (theme) => theme.palette.mode === "dark" ? "0 2px 8px rgba(255, 255, 255, 0.15)" : "0 2px 8px rgba(0, 0, 0, 0.1)",
+                      transform: "translateY(-1px)"
+                    }
+                  },
+                  children: /* @__PURE__ */ jsx4(
+                    Typography,
+                    {
+                      variant: "body2",
+                      className: "search-result-text",
+                      sx: {
+                        fontSize: "0.875rem",
+                        lineHeight: 1.6,
+                        color: result.index === currentResultIndex ? "text.primary" : "text.secondary"
+                      },
+                      children: highlightText(result.context, searchTerm)
+                    }
+                  )
+                },
+                index
+              ))
+            ] }, pageNumber);
+          }) })
+        ] })
+      ]
+    }
+  );
+};
+
+// src/components/viewers/pdf/PasswordDialog.tsx
+import { useState as useState2, useEffect as useEffect2 } from "react";
+import {
+  Dialog,
+  DialogTitle,
+  DialogContent,
+  DialogActions,
+  TextField as TextField2,
+  Button,
+  Typography as Typography2,
+  IconButton as IconButton2,
+  InputAdornment as InputAdornment2,
+  Box as Box2,
+  Alert
+} from "@mui/material";
+import CloseIcon2 from "@mui/icons-material/Close";
+import LockIcon from "@mui/icons-material/Lock";
+import VisibilityIcon from "@mui/icons-material/Visibility";
+import VisibilityOffIcon from "@mui/icons-material/VisibilityOff";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var PasswordDialog = ({
+  open,
+  fileName,
+  onSubmit,
+  onCancel,
+  error
+}) => {
+  const [password, setPassword] = useState2("");
+  const [showPassword, setShowPassword] = useState2(false);
+  useEffect2(() => {
+    if (open) {
+      setPassword("");
+      setShowPassword(false);
+    }
+  }, [open]);
+  const handleSubmit = (e) => {
+    e.preventDefault();
+    if (password.trim()) {
+      onSubmit(password);
+    }
+  };
+  const handleTogglePasswordVisibility = () => {
+    setShowPassword(!showPassword);
+  };
+  const handleKeyPress = (e) => {
+    if (e.key === "Enter" && password.trim()) {
+      handleSubmit(e);
+    }
+  };
+  return /* @__PURE__ */ jsxs4(
+    Dialog,
+    {
+      open,
+      onClose: onCancel,
+      maxWidth: "sm",
+      fullWidth: true,
+      PaperProps: {
+        sx: {
+          borderRadius: 2
+        }
+      },
+      children: [
+        /* @__PURE__ */ jsx5(DialogTitle, { sx: { pb: 1 }, children: /* @__PURE__ */ jsxs4(Box2, { sx: { display: "flex", alignItems: "center", justifyContent: "space-between" }, children: [
+          /* @__PURE__ */ jsxs4(Box2, { sx: { display: "flex", alignItems: "center", gap: 1.5 }, children: [
+            /* @__PURE__ */ jsx5(
+              Box2,
+              {
+                sx: {
+                  width: 40,
+                  height: 40,
+                  borderRadius: "50%",
+                  backgroundColor: "primary.light",
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  opacity: 0.9
+                },
+                children: /* @__PURE__ */ jsx5(LockIcon, { sx: { color: "white", fontSize: 20 } })
+              }
+            ),
+            /* @__PURE__ */ jsx5(Typography2, { variant: "h6", component: "div", sx: { fontWeight: 600 }, children: "Password Protected" })
+          ] }),
+          /* @__PURE__ */ jsx5(
+            IconButton2,
+            {
+              size: "small",
+              onClick: onCancel,
+              sx: { color: "text.secondary" },
+              "aria-label": "Close dialog",
+              children: /* @__PURE__ */ jsx5(CloseIcon2, { fontSize: "small" })
+            }
+          )
+        ] }) }),
+        /* @__PURE__ */ jsxs4(DialogContent, { sx: { pt: 2 }, children: [
+          /* @__PURE__ */ jsxs4(Typography2, { variant: "body2", sx: { color: "text.secondary", mb: 3 }, children: [
+            "This PDF is password protected. Please enter the password to view",
+            " ",
+            fileName && /* @__PURE__ */ jsxs4("strong", { children: [
+              '"',
+              fileName,
+              '"'
+            ] })
+          ] }),
+          error && /* @__PURE__ */ jsx5(Alert, { severity: "error", sx: { mb: 2 }, children: error }),
+          /* @__PURE__ */ jsx5("form", { onSubmit: handleSubmit, children: /* @__PURE__ */ jsx5(
+            TextField2,
+            {
+              fullWidth: true,
+              autoFocus: true,
+              type: showPassword ? "text" : "password",
+              label: "Password",
+              placeholder: "Enter password",
+              value: password,
+              onChange: (e) => setPassword(e.target.value),
+              onKeyPress: handleKeyPress,
+              error: Boolean(error),
+              InputProps: {
+                endAdornment: /* @__PURE__ */ jsx5(InputAdornment2, { position: "end", children: /* @__PURE__ */ jsx5(
+                  IconButton2,
+                  {
+                    onClick: handleTogglePasswordVisibility,
+                    edge: "end",
+                    size: "small",
+                    "aria-label": showPassword ? "Hide password" : "Show password",
+                    children: showPassword ? /* @__PURE__ */ jsx5(VisibilityOffIcon, {}) : /* @__PURE__ */ jsx5(VisibilityIcon, {})
+                  }
+                ) })
+              },
+              sx: {
+                "& .MuiOutlinedInput-root": {
+                  borderRadius: 2
+                }
+              }
+            }
+          ) })
+        ] }),
+        /* @__PURE__ */ jsxs4(DialogActions, { sx: { px: 3, pb: 3, pt: 2 }, children: [
+          /* @__PURE__ */ jsx5(
+            Button,
+            {
+              onClick: onCancel,
+              variant: "outlined",
+              sx: {
+                borderRadius: 2,
+                textTransform: "none",
+                px: 3
+              },
+              children: "Cancel"
+            }
+          ),
+          /* @__PURE__ */ jsx5(
+            Button,
+            {
+              onClick: handleSubmit,
+              variant: "contained",
+              disabled: !password.trim(),
+              sx: {
+                borderRadius: 2,
+                textTransform: "none",
+                px: 3,
+                boxShadow: 2
+              },
+              children: "Unlock PDF"
+            }
+          )
+        ] })
+      ]
+    }
+  );
+};
+
+// src/components/viewers/PDFViewer.tsx
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+var PDFViewerContent = forwardRef(
+  (props, ref) => {
+    const {
+      file,
+      onLoad,
+      onError,
+      fileName,
+      showPageCount = true,
+      showPageNavigation = true,
+      showZoomControls = true,
+      showRotation = true,
+      showDownload = true,
+      showPrint = true,
+      showSearch = true,
+      showMetadata = true,
+      showProperties = true,
+      showTags = true,
+      onMetadataClick,
+      onPropertiesClick,
+      onTagsClick,
+      onDownloadClick,
+      onPrintClick,
+      initialSearchText,
+      initialSearchPages
+    } = props;
+    const [pdfBuffer, setPdfBuffer] = useState3(null);
+    const [state, setState] = useState3("idle");
+    const [error, setError] = useState3(null);
+    const pdfViewerRef = useRef2(null);
+    const resolvedFileName = useMemo(() => {
+      if (fileName) return fileName;
+      if (file instanceof File) return file.name;
+      if (typeof file === "string") {
+        const urlParts = file.split("/");
+        return urlParts[urlParts.length - 1] || "document.pdf";
+      }
+      return "document.pdf";
+    }, [file, fileName]);
+    const fileExtension = useMemo(
+      () => getFileExtension(resolvedFileName),
+      [resolvedFileName]
+    );
+    const [currentPage, setCurrentPage] = useState3(1);
+    const [totalPages, setTotalPages] = useState3(0);
+    const [zoom, setZoom] = useState3(100);
+    const [searchQuery, setSearchQuery] = useState3("");
+    const [isSearching, setIsSearching] = useState3(false);
+    const [pdfContainer, setPdfContainer] = useState3(null);
+    const [isSidebarOpen, setIsSidebarOpen] = useState3(false);
+    const [searchResults, setSearchResults] = useState3([]);
+    const [currentSearchResultIndex, setCurrentSearchResultIndex] = useState3(0);
+    const [totalSearchResults, setTotalSearchResults] = useState3(0);
+    const [autoExecuteSearch, setAutoExecuteSearch] = useState3(
+      !!initialSearchText
+    );
+    const [isFullScreen, setIsFullScreen] = useState3(false);
+    const containerRef = useRef2(null);
+    const [isPasswordDialogOpen, setIsPasswordDialogOpen] = useState3(false);
+    const [passwordError, setPasswordError] = useState3("");
+    const [passwordResolve, setPasswordResolve] = useState3(null);
+    const hasExecutedInitialSearch = useRef2(false);
+    const handleToggleFullScreen = useCallback(() => {
+      if (!isFullScreen && containerRef.current?.requestFullscreen) {
+        containerRef.current.requestFullscreen();
+        setIsFullScreen(true);
+      } else if (isFullScreen && document.exitFullscreen) {
+        document.exitFullscreen();
+        setIsFullScreen(false);
+      }
+    }, [isFullScreen]);
+    const handleSidebarClose = useCallback(() => {
+      setIsSidebarOpen(false);
+      setSearchQuery("");
+      setSearchResults([]);
+      setTotalSearchResults(0);
+      setCurrentSearchResultIndex(0);
+      pdfViewerRef.current?.search.stopSearch();
+    }, []);
+    const toolbar = mergeToolbarConfig({
+      showDownload,
+      showPrint,
+      showMetadata,
+      showProperties,
+      showTags,
+      showRotation,
+      onDownloadClick,
+      onPrintClick,
+      onMetadataClick,
+      onPropertiesClick,
+      onTagsClick,
+      toolbarActions: props.toolbarActions
+    });
+    const toolbarHandlers = useMemo(
+      () => ({
+        handleZoomIn: () => {
+          pdfViewerRef.current?.zoom.zoomIn();
+          requestAnimationFrame(() => {
+            const zoomValue = pdfViewerRef.current?.zoom.getZoom();
+            if (typeof zoomValue === "number") {
+              setZoom(Math.round(zoomValue * 100));
+            }
+          });
+        },
+        handleZoomOut: () => {
+          pdfViewerRef.current?.zoom.zoomOut();
+          requestAnimationFrame(() => {
+            const zoomValue = pdfViewerRef.current?.zoom.getZoom();
+            if (typeof zoomValue === "number") {
+              setZoom(Math.round(zoomValue * 100));
+            }
+          });
+        },
+        handleFitToWidth: () => {
+          pdfViewerRef.current?.zoom.fitToWidth();
+          requestAnimationFrame(() => {
+            const zoomValue = pdfViewerRef.current?.zoom.getZoom();
+            if (typeof zoomValue === "number") {
+              setZoom(Math.round(zoomValue * 100));
+            }
+          });
+        },
+        handleFitToPage: () => {
+          pdfViewerRef.current?.zoom.fitToPage();
+          requestAnimationFrame(() => {
+            const zoomValue = pdfViewerRef.current?.zoom.getZoom();
+            if (typeof zoomValue === "number") {
+              setZoom(Math.round(zoomValue * 100));
+            }
+          });
+        },
+        handlePreviousPage: () => {
+          pdfViewerRef.current?.navigation.previousPage();
+          requestAnimationFrame(() => {
+            const current = pdfViewerRef.current?.navigation.getCurrentPage() || 1;
+            setCurrentPage(current);
+          });
+        },
+        handleNextPage: () => {
+          pdfViewerRef.current?.navigation.nextPage();
+          requestAnimationFrame(() => {
+            const current = pdfViewerRef.current?.navigation.getCurrentPage() || 1;
+            setCurrentPage(current);
+          });
+        },
+        handleFirstPage: () => {
+          pdfViewerRef.current?.navigation.goToFirstPage();
+          requestAnimationFrame(() => {
+            const current = pdfViewerRef.current?.navigation.getCurrentPage() || 1;
+            setCurrentPage(current);
+          });
+        },
+        handleLastPage: () => {
+          pdfViewerRef.current?.navigation.goToLastPage();
+          requestAnimationFrame(() => {
+            const current = pdfViewerRef.current?.navigation.getCurrentPage() || 1;
+            setCurrentPage(current);
+          });
+        },
+        toggleSidebar: () => {
+          if (isSidebarOpen) {
+            handleSidebarClose();
+          } else {
+            setIsSidebarOpen(true);
+          }
+        },
+        handlePageInput: (e) => {
+          const value = e.target.value;
+          if (/^\d*$/.test(value)) {
+            return;
+          }
+          const page = parseInt(value, 10);
+          if (!isNaN(page) && page >= 1 && (totalPages === 0 || page <= totalPages)) {
+            pdfViewerRef.current?.navigation.goToPage(page);
+            setCurrentPage(page);
+          }
+        },
+        handlePageInputKeyPress: (e) => {
+          if (e.key === "Enter") {
+            const value = e.target.value;
+            const page = parseInt(value, 10);
+            if (!isNaN(page) && page >= 1 && (totalPages === 0 || page <= totalPages)) {
+              pdfViewerRef.current?.navigation.goToPage(page);
+              setCurrentPage(page);
+            }
+          }
+        },
+        handleRotateLeft: () => {
+          pdfViewerRef.current?.rotate?.rotateBackward();
+        },
+        handleRotateRight: () => {
+          pdfViewerRef.current?.rotate?.rotateForward();
+        },
+        handleToggleFullScreen
+      }),
+      [isSidebarOpen, totalPages, handleToggleFullScreen]
+    );
+    useEffect3(() => {
+      console.log(
+        "came",
+        initialSearchText,
+        pdfViewerRef.current,
+        hasExecutedInitialSearch.current,
+        "state:",
+        state,
+        "totalPages:",
+        totalPages
+      );
+      if (!initialSearchText || hasExecutedInitialSearch.current) return;
+      const isPDFReady = state === "ready";
+      const isPagesInitialized = totalPages > 0;
+      const isViewerAvailable = !!pdfViewerRef.current;
+      const isSearchAPIReady = !!pdfViewerRef.current?.search?.searchText;
+      const canExecuteSearch = isPDFReady && isPagesInitialized && isViewerAvailable && isSearchAPIReady;
+      if (!canExecuteSearch) return;
+      hasExecutedInitialSearch.current = true;
+      const SEARCH_INITIALIZATION_DELAY = 100;
+      setTimeout(() => {
+        if (!pdfViewerRef.current?.search?.searchText) {
+          console.warn(
+            "Search API became unavailable, skipping initial search"
+          );
+          hasExecutedInitialSearch.current = false;
+          return;
+        }
+        requestAnimationFrame(() => {
+          requestAnimationFrame(() => {
+            setIsSidebarOpen(true);
+            handleSidebarSearch(initialSearchText, initialSearchPages);
+            setAutoExecuteSearch(false);
+          });
+        });
+      }, SEARCH_INITIALIZATION_DELAY);
+    }, [
+      state,
+      totalPages,
+      pdfViewerRef.current,
+      initialSearchText,
+      initialSearchPages
+    ]);
+    useEffect3(() => {
+      setSearchQuery("");
+      setSearchResults([]);
+      setCurrentSearchResultIndex(0);
+      setTotalSearchResults(0);
+      setIsSearching(false);
+      setIsSidebarOpen(false);
+      hasExecutedInitialSearch.current = false;
+      setCurrentPage(1);
+      setTotalPages(0);
+      setZoom(100);
+      setState("idle");
+      setError(null);
+      setPdfBuffer(null);
+    }, [file]);
+    useEffect3(() => {
+      if (state !== "ready") return;
+      const container = document.querySelector(
+        '[data-pdf-viewer], .embedpdf-viewport, [role="document"]'
+      );
+      if (container) {
+        setPdfContainer(container);
+        return;
+      }
+      const observer = new MutationObserver(() => {
+        const foundContainer = document.querySelector(
+          '[data-pdf-viewer], .embedpdf-viewport, [role="document"]'
+        );
+        if (foundContainer) {
+          setPdfContainer(foundContainer);
+          observer.disconnect();
+        }
+      });
+      observer.observe(document.body, { childList: true, subtree: true });
+      return () => observer.disconnect();
+    }, [state]);
+    useEffect3(() => {
+      if (state !== "ready" || totalPages > 0) return;
+      const initializePageCount = async () => {
+        const waitForViewer = async (maxAttempts = 10) => {
+          for (let i = 0; i < maxAttempts; i++) {
+            if (pdfViewerRef.current) return pdfViewerRef.current;
+            await new Promise(
+              (resolve) => requestAnimationFrame(
+                () => setTimeout(resolve, Math.min(100 * Math.pow(2, i), 1e3))
+              )
+            );
+          }
+          return null;
+        };
+        const viewer = await waitForViewer();
+        if (!viewer) return;
+        await new Promise((resolve) => requestAnimationFrame(resolve));
+        try {
+          const count = viewer.navigation?.getTotalPages?.();
+          if (count && count > 1) {
+            setTotalPages(count);
+            return;
+          }
+        } catch (e) {
+        }
+        try {
+          const results = await viewer.search?.searchText?.("e");
+          if (results?.results && results.results.length > 0) {
+            const pageIndices = results.results.map((m) => m.pageIndex).filter((idx) => typeof idx === "number");
+            const count = Math.max(...pageIndices) + 1;
+            viewer.search?.stopSearch?.();
+            setTotalPages(count);
+            return;
+          }
+        } catch (error2) {
+        }
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        try {
+          const selectors = [
+            "[data-page-index]",
+            "[data-page-number]",
+            ".embedpdf-page",
+            '[role="article"]',
+            "canvas[data-page]",
+            ".react-pdf__Page"
+          ];
+          for (const selector of selectors) {
+            const pages = document.querySelectorAll(selector);
+            if (pages.length > 0) {
+              setTotalPages(pages.length);
+              return;
+            }
+          }
+        } catch (error2) {
+        }
+        try {
+          const count = viewer.navigation?.getTotalPages?.();
+          if (count && count > 0) {
+            setTotalPages(count);
+            return;
+          }
+        } catch (e) {
+        }
+        console.warn(
+          "Could not determine total pages, using fallback value of 1"
+        );
+        setTotalPages(1);
+      };
+      initializePageCount();
+    }, [state, totalPages]);
+    useEffect3(() => {
+      if (state === "ready" && pdfViewerRef.current) {
+        const updateInfo = () => {
+          const current = pdfViewerRef.current?.navigation.getCurrentPage() || 1;
+          const total = pdfViewerRef.current?.navigation.getTotalPages() || 0;
+          const zoomValue = pdfViewerRef.current?.zoom.getZoom();
+          const currentSearchState = pdfViewerRef.current?.search.getSearchState();
+          setCurrentPage(current);
+          if (total > 0 && total !== totalPages) {
+            setTotalPages(total);
+          }
+          if (typeof zoomValue === "number") {
+            setZoom(Math.round(zoomValue * 100));
+          }
+        };
+        updateInfo();
+        const interval = setInterval(updateInfo, 300);
+        return () => clearInterval(interval);
+      }
+    }, [state, totalPages]);
+    useImperativeHandle(
+      ref,
+      () => ({
+        zoomIn: () => {
+          pdfViewerRef.current?.zoom.zoomIn();
+          updateZoomDisplay();
+        },
+        zoomOut: () => {
+          pdfViewerRef.current?.zoom.zoomOut();
+          updateZoomDisplay();
+        },
+        setZoom: (level) => {
+          pdfViewerRef.current?.zoom.setZoom(level);
+          updateZoomDisplay();
+        },
+        resetZoom: () => {
+          pdfViewerRef.current?.zoom.resetZoom();
+          updateZoomDisplay();
+        },
+        getZoom: () => {
+          const zoom2 = pdfViewerRef.current?.zoom.getZoom();
+          return typeof zoom2 === "number" ? zoom2 : 1;
+        },
+        goToPage: (page) => {
+          pdfViewerRef.current?.navigation.goToPage(page);
+          setCurrentPage(page);
+        },
+        getCurrentPage: () => pdfViewerRef.current?.navigation.getCurrentPage() || 1,
+        getTotalPages: () => pdfViewerRef.current?.navigation.getTotalPages() || 0,
+        nextPage: () => {
+          pdfViewerRef.current?.navigation.nextPage();
+          updatePageDisplay();
+        },
+        previousPage: () => {
+          pdfViewerRef.current?.navigation.previousPage();
+          updatePageDisplay();
+        },
+        goToFirstPage: () => {
+          pdfViewerRef.current?.navigation.goToFirstPage();
+          updatePageDisplay();
+        },
+        goToLastPage: () => {
+          pdfViewerRef.current?.navigation.goToLastPage();
+          updatePageDisplay();
+        },
+        searchText: async (keyword) => {
+          setIsSearching(true);
+          const results = await pdfViewerRef.current?.search.searchText(
+            keyword
+          );
+          setIsSearching(false);
+          setSearchQuery(keyword);
+          return results;
+        },
+        nextResult: () => {
+          const index = pdfViewerRef.current?.search.nextResult() || -1;
+          return index;
+        },
+        previousResult: () => {
+          const index = pdfViewerRef.current?.search.previousResult() || -1;
+          return index;
+        },
+        goToResult: (index) => pdfViewerRef.current?.search.goToResult(index) || -1,
+        stopSearch: () => {
+          pdfViewerRef.current?.search.stopSearch();
+          setSearchQuery("");
+        },
+        getSearchState: () => pdfViewerRef.current?.search.getSearchState() || null,
+        getSelectedText: () => pdfViewerRef.current?.selection.getSelectedText() || "",
+        clearSelection: () => pdfViewerRef.current?.selection.clearSelection(),
+        rotateForward: () => pdfViewerRef.current?.rotate?.rotateForward(),
+        rotateBackward: () => pdfViewerRef.current?.rotate?.rotateBackward(),
+        getRotation: () => pdfViewerRef.current?.rotate?.getRotation() || 0
+      }),
+      []
+    );
+    const updatePageDisplay = () => {
+      requestAnimationFrame(() => {
+        const current = pdfViewerRef.current?.navigation.getCurrentPage() || 1;
+        setCurrentPage(current);
+      });
+    };
+    const updateZoomDisplay = () => {
+      requestAnimationFrame(() => {
+        const zoomValue = pdfViewerRef.current?.zoom.getZoom();
+        if (typeof zoomValue === "number") {
+          setZoom(Math.round(zoomValue * 100));
+        }
+      });
+    };
+    const handleSearch = async () => {
+      if (!searchQuery.trim()) return;
+      setIsSearching(true);
+      const results = await pdfViewerRef.current?.search.searchText(
+        searchQuery
+      );
+      setIsSearching(false);
+      if (results?.results && Array.isArray(results.results) && results.results.length > 0) {
+        const formattedResults = formatSearchResults(results.results);
+        updateSearchState(formattedResults);
+      } else {
+        clearSearchResults();
+      }
+    };
+    const handleSearchKeyPress = (e) => {
+      if (e.key === "Enter") {
+        handleSearch();
+      }
+    };
+    const handleSidebarSearch = async (keyword, pageNumbers) => {
+      setSearchQuery(keyword);
+      if (!keyword.trim()) {
+        setSearchResults([]);
+        setTotalSearchResults(0);
+        setCurrentSearchResultIndex(0);
+        pdfViewerRef.current?.search.stopSearch();
+        return;
+      }
+      if (!pdfViewerRef.current?.search?.searchText) {
+        console.warn("Search functionality not yet available");
+        return;
+      }
+      setIsSearching(true);
+      try {
+        const results = await pdfViewerRef.current.search.searchText(keyword);
+        console.log("Search completed:", results);
+        setIsSearching(false);
+        const hasValidResults = results?.results && Array.isArray(results.results) && results.results.length > 0;
+        if (hasValidResults) {
+          const formattedResults = formatSearchResults(results.results);
+          updateSearchState(formattedResults);
+          navigateToFirstResult(formattedResults);
+        } else if (pageNumbers && pageNumbers.length > 0) {
+          const fallbackResults = createFallbackResults(pageNumbers, keyword);
+          updateSearchState(fallbackResults);
+          navigateToPage(pageNumbers[0]);
+        } else {
+          clearSearchResults();
+        }
+      } catch (error2) {
+        console.error("Search failed:", error2);
+        setIsSearching(false);
+        clearSearchResults();
+      }
+    };
+    const formatSearchResults = (results) => {
+      return results.map((result, index) => {
+        let textContent = "";
+        let contextContent = "";
+        if (result.context && typeof result.context === "object") {
+          const { before = "", match = "", after = "" } = result.context;
+          textContent = match;
+          contextContent = `${before}${match}${after}`;
+        } else if (typeof result === "string") {
+          textContent = result;
+          contextContent = result;
+        } else {
+          textContent = String(result.match || result.text || "");
+          contextContent = textContent;
+        }
+        return {
+          pageNumber: (result.pageIndex ?? result.pageNumber ?? 0) + 1,
+          text: textContent,
+          context: contextContent,
+          index
+        };
+      });
+    };
+    const createFallbackResults = (pageNumbers, keyword) => {
+      return pageNumbers.map((pageNum, index) => ({
+        pageNumber: pageNum,
+        text: keyword,
+        context: `"${keyword}" found on this page ${pageNum}`,
+        index
+      }));
+    };
+    const updateSearchState = (results) => {
+      setSearchResults(results);
+      setTotalSearchResults(results.length);
+      setCurrentSearchResultIndex(0);
+    };
+    const clearSearchResults = () => {
+      setSearchResults([]);
+      setTotalSearchResults(0);
+      setCurrentSearchResultIndex(0);
+    };
+    const navigateToFirstResult = (results) => {
+      if (results.length > 0) {
+        navigateToPage(results[0].pageNumber);
+      }
+    };
+    const navigateToPage = (pageNumber) => {
+      requestAnimationFrame(() => {
+        pdfViewerRef.current?.navigation.goToPage(pageNumber);
+        setCurrentPage(pageNumber);
+      });
+    };
+    const handleSearchResultClick = (pageNumber, resultIndex) => {
+      pdfViewerRef.current?.navigation.goToPage(pageNumber);
+      setCurrentSearchResultIndex(resultIndex);
+      setCurrentPage(pageNumber);
+      pdfViewerRef.current?.search.goToResult(resultIndex);
+    };
+    const handleNextSearchResult = () => {
+      if (currentSearchResultIndex < totalSearchResults - 1) {
+        const nextIndex = currentSearchResultIndex + 1;
+        setCurrentSearchResultIndex(nextIndex);
+        pdfViewerRef.current?.search.nextResult();
+        if (searchResults[nextIndex]) {
+          const pageNumber = searchResults[nextIndex].pageNumber;
+          pdfViewerRef.current?.navigation.goToPage(pageNumber);
+          setCurrentPage(pageNumber);
+        }
+      }
+    };
+    const handlePreviousSearchResult = () => {
+      if (currentSearchResultIndex > 0) {
+        const prevIndex = currentSearchResultIndex - 1;
+        setCurrentSearchResultIndex(prevIndex);
+        pdfViewerRef.current?.search.previousResult();
+        if (searchResults[prevIndex]) {
+          const pageNumber = searchResults[prevIndex].pageNumber;
+          pdfViewerRef.current?.navigation.goToPage(pageNumber);
+          setCurrentPage(pageNumber);
+        }
+      }
+    };
+    useEffect3(() => {
+      if (!file) {
+        setState("error");
+        setError("No file provided");
+        return;
+      }
+      const loadPDF = async () => {
+        try {
+          setState("loading");
+          setError(null);
+          let arrayBuffer;
+          if (file instanceof File) {
+            arrayBuffer = await file.arrayBuffer();
+          } else if (typeof file === "string") {
+            const response = await fetch(file);
+            if (!response.ok) {
+              throw new Error(`Failed to load PDF: ${response.statusText}`);
+            }
+            arrayBuffer = await response.arrayBuffer();
+          } else if (file instanceof ArrayBuffer) {
+            arrayBuffer = file;
+          } else {
+            throw new Error("Unsupported file type");
+          }
+          setPdfBuffer(arrayBuffer);
+          setState("ready");
+          onLoad?.();
+        } catch (err) {
+          const errorMessage = err.message || "Failed to load PDF";
+          setState("error");
+          setError(errorMessage);
+          onError?.(err);
+        }
+      };
+      loadPDF();
+    }, [file, onLoad, onError]);
+    const handlePasswordRequest = useCallback(
+      async (fileName2) => {
+        return new Promise((resolve) => {
+          setPasswordResolve(() => resolve);
+          setPasswordError("");
+          setIsPasswordDialogOpen(true);
+        });
+      },
+      []
+    );
+    const handlePasswordSubmit = useCallback(
+      (password) => {
+        if (passwordResolve) {
+          passwordResolve(password);
+          setPasswordResolve(null);
+          setIsPasswordDialogOpen(false);
+          setPasswordError("");
+        }
+      },
+      [passwordResolve]
+    );
+    const handlePasswordCancel = useCallback(() => {
+      if (passwordResolve) {
+        passwordResolve(null);
+        setPasswordResolve(null);
+        setIsPasswordDialogOpen(false);
+        setPasswordError("");
+      }
+    }, [passwordResolve]);
+    if (state === "loading") {
+      return /* @__PURE__ */ jsxs5(
+        "div",
+        {
+          style: {
+            display: "flex",
+            flexDirection: "column",
+            alignItems: "center",
+            justifyContent: "center",
+            height: "100%",
+            gap: "16px"
+          },
+          children: [
+            /* @__PURE__ */ jsx6(
+              "div",
+              {
+                className: "spinner",
+                style: {
+                  width: "48px",
+                  height: "48px",
+                  border: "4px solid #f3f3f3",
+                  borderTop: "4px solid #3498db",
+                  borderRadius: "50%",
+                  animation: "spin 1s linear infinite"
+                }
+              }
+            ),
+            /* @__PURE__ */ jsx6("p", { children: "Loading PDF..." }),
+            /* @__PURE__ */ jsx6("style", { children: `
+          @keyframes spin {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+          }
+        ` })
+          ]
+        }
+      );
+    }
+    if (state === "error" || error) {
+      return /* @__PURE__ */ jsx6(
+        "div",
+        {
+          style: {
+            display: "flex",
+            flexDirection: "column",
+            alignItems: "center",
+            justifyContent: "center",
+            height: "100%",
+            padding: "24px"
+          },
+          children: /* @__PURE__ */ jsxs5(
+            "div",
+            {
+              style: {
+                maxWidth: "400px",
+                padding: "16px",
+                backgroundColor: "#fee",
+                border: "1px solid #fcc",
+                borderRadius: "4px"
+              },
+              children: [
+                /* @__PURE__ */ jsx6("h3", { style: { marginTop: 0 }, children: "Failed to Load PDF" }),
+                /* @__PURE__ */ jsx6("p", { children: error || "Unknown error occurred" })
+              ]
+            }
+          )
+        }
+      );
+    }
+    if (!pdfBuffer || state !== "ready") {
+      return /* @__PURE__ */ jsx6(
+        "div",
+        {
+          style: {
+            display: "flex",
+            alignItems: "center",
+            justifyContent: "center",
+            height: "100%"
+          },
+          children: /* @__PURE__ */ jsx6("p", { children: "Preparing PDF..." })
+        }
+      );
+    }
+    return /* @__PURE__ */ jsxs5("div", { ref: containerRef, className: "pdf-viewer-container", children: [
+      /* @__PURE__ */ jsx6("style", { children: toolbarStyles }),
+      /* @__PURE__ */ jsx6(PDFHeader, { fileName: resolvedFileName, fileExtension }),
+      /* @__PURE__ */ jsx6(
+        PDFToolbar,
+        {
+          currentPage,
+          totalPages,
+          zoom,
+          isSidebarOpen,
+          showPageNavigation,
+          showPageCount,
+          showZoomControls,
+          showSearch,
+          showRotation: !toolbar.isHidden("rotation"),
+          showMetadata: !toolbar.isHidden("metadata"),
+          showProperties: !toolbar.isHidden("properties"),
+          showDownload: !toolbar.isHidden("download"),
+          showPrint: !toolbar.isHidden("print"),
+          showTags: !toolbar.isHidden("tags"),
+          disabledRotateLeft: toolbar.isDisabled("rotateLeft"),
+          disabledRotateRight: toolbar.isDisabled("rotateRight"),
+          disabledMetadata: toolbar.isDisabled("metadata"),
+          disabledTags: toolbar.isDisabled("tags"),
+          disabledProperties: toolbar.isDisabled("properties"),
+          disabledDownload: toolbar.isDisabled("download"),
+          disabledPrint: toolbar.isDisabled("print"),
+          onFirstPage: toolbarHandlers.handleFirstPage,
+          onPreviousPage: toolbarHandlers.handlePreviousPage,
+          onNextPage: toolbarHandlers.handleNextPage,
+          onLastPage: toolbarHandlers.handleLastPage,
+          onPageInput: toolbarHandlers.handlePageInput,
+          onPageInputKeyPress: toolbarHandlers.handlePageInputKeyPress,
+          onZoomIn: toolbarHandlers.handleZoomIn,
+          onZoomOut: toolbarHandlers.handleZoomOut,
+          onFitToWidth: toolbarHandlers.handleFitToWidth,
+          onFitToPage: toolbarHandlers.handleFitToPage,
+          onToggleSidebar: toolbarHandlers.toggleSidebar,
+          onToggleFullScreen: toolbarHandlers.handleToggleFullScreen,
+          onRotateLeft: toolbarHandlers.handleRotateLeft,
+          onRotateRight: toolbarHandlers.handleRotateRight,
+          onDownloadClick: toolbar.getHandler("download", onDownloadClick),
+          onPrintClick: toolbar.getHandler("print", onPrintClick),
+          onMetadataClick: toolbar.getHandler("metadata", onMetadataClick),
+          onPropertiesClick: toolbar.getHandler(
+            "properties",
+            onPropertiesClick
+          ),
+          onTagsClick: toolbar.getHandler("tags", onTagsClick)
+        }
+      ),
+      /* @__PURE__ */ jsxs5("div", { className: "pdf-viewer-main", children: [
+        /* @__PURE__ */ jsx6("div", { className: "pdf-viewer-viewer-area", children: /* @__PURE__ */ jsx6(
+          StablePDFViewer,
+          {
+            pdfBuffer,
+            onPasswordRequest: handlePasswordRequest,
+            pdfViewerRef
+          }
+        ) }),
+        /* @__PURE__ */ jsx6(
+          SearchSidebar,
+          {
+            isOpen: isSidebarOpen,
+            onClose: handleSidebarClose,
+            onSearch: handleSidebarSearch,
+            onSearchResultClick: handleSearchResultClick,
+            onNextResult: handleNextSearchResult,
+            onPreviousResult: handlePreviousSearchResult,
+            currentResultIndex: currentSearchResultIndex,
+            totalResults: totalSearchResults,
+            searchKeyword: searchQuery,
+            searchResults,
+            isSearching
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx6(
+        PasswordDialog,
+        {
+          open: isPasswordDialogOpen,
+          fileName: resolvedFileName,
+          onSubmit: handlePasswordSubmit,
+          onCancel: handlePasswordCancel,
+          error: passwordError
+        }
+      )
+    ] });
+  }
+);
+PDFViewerContent.displayName = "PDFViewerContent";
+var PDFViewer = forwardRef(
+  (props, ref) => {
+    return /* @__PURE__ */ jsx6(PDFViewerContent, { ...props, sourceDescription: "doc.pdf", ref });
+  }
+);
+PDFViewer.displayName = "PDFViewer";
+
+export {
+  PDFViewer
+};
+//# sourceMappingURL=chunk-TMAHQICY.mjs.map