@lamberl-lee/file-preview 0.2.0

package/dist/EpubPreview.js

@@ -0,0 +1,693 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useEffect, useState, useCallback, useRef } from "react";
+import JSZip from "jszip";
+import {
+  BookOpenIcon,
+  ChevronLeftIcon,
+  ChevronRightIcon,
+  ListIcon,
+  SearchIcon,
+  XIcon,
+  ChevronDownIcon
+} from "./icons";
+import { base64ToUint8Array } from "./utils";
+import { useLocale } from "./core/i18n";
+import "./styles/EpubPreview.css";
+async function parseEpub(base64Content) {
+  const bytes = base64ToUint8Array(base64Content);
+  const zip = await JSZip.loadAsync(bytes);
+  const chapters = [];
+  const toc = [];
+  let bookTitle = "";
+  let bookAuthor = "";
+  const stylesheets = [];
+  const imageMap = {};
+  function getAttr(tag, attrName) {
+    const re = new RegExp(`${attrName}="([^"]*)"`, "i");
+    const m = tag.match(re);
+    return m ? m[1] : null;
+  }
+  function resolvePath(baseDir, relativePath) {
+    if (relativePath.startsWith("/")) return relativePath.substring(1);
+    const decoded = decodeURIComponent(relativePath);
+    const pathPart = decoded.split("#")[0];
+    if (!pathPart) return baseDir;
+    const baseParts = baseDir.split("/").filter(Boolean);
+    const relParts = pathPart.split("/");
+    for (const part of relParts) {
+      if (part === "..") {
+        baseParts.pop();
+      } else if (part !== "." && part !== "") {
+        baseParts.push(part);
+      }
+    }
+    return baseParts.join("/");
+  }
+  function findZipFile(path) {
+    let f = zip.file(path);
+    if (f) return f;
+    try {
+      f = zip.file(decodeURIComponent(path));
+      if (f) return f;
+    } catch {
+    }
+    const lowerPath = path.toLowerCase();
+    let found = null;
+    zip.forEach((p, file) => {
+      if (!found && p.toLowerCase() === lowerPath) {
+        found = file;
+      }
+    });
+    return found;
+  }
+  const imageExtensions = [".jpg", ".jpeg", ".png", ".gif", ".svg", ".webp", ".bmp"];
+  const imagePromises = [];
+  zip.forEach((path, file) => {
+    if (file.dir) return;
+    const lowerPath = path.toLowerCase();
+    if (imageExtensions.some((ext) => lowerPath.endsWith(ext))) {
+      imagePromises.push(
+        (async () => {
+          try {
+            const blob = await file.async("blob");
+            const url = URL.createObjectURL(blob);
+            imageMap[path] = url;
+            const filename = path.split("/").pop();
+            imageMap[filename] = url;
+            imageMap[lowerPath] = url;
+            imageMap[filename.toLowerCase()] = url;
+          } catch {
+          }
+        })()
+      );
+    }
+  });
+  await Promise.all(imagePromises);
+  const containerFile = zip.file("META-INF/container.xml");
+  if (!containerFile) {
+    throw new Error("Invalid EPUB: missing container.xml");
+  }
+  const containerXml = await containerFile.async("string");
+  const rootfileMatch = containerXml.match(/full-path="([^"]+)"/);
+  if (!rootfileMatch) {
+    throw new Error("Invalid EPUB: no rootfile in container.xml");
+  }
+  const opfPath = rootfileMatch[1];
+  const opfFile = findZipFile(opfPath);
+  if (!opfFile) {
+    throw new Error("Invalid EPUB: OPF file not found");
+  }
+  const opfXml = await opfFile.async("string");
+  const opfDir = opfPath.includes("/") ? opfPath.substring(0, opfPath.lastIndexOf("/") + 1) : "";
+  const titleMatch = opfXml.match(/<dc:title[^>]*>([\s\S]*?)<\/dc:title>/);
+  if (titleMatch) bookTitle = titleMatch[1].trim();
+  const authorMatch = opfXml.match(/<dc:creator[^>]*>([\s\S]*?)<\/dc:creator>/);
+  if (authorMatch) bookAuthor = authorMatch[1].trim();
+  const manifestMatch = opfXml.match(/<manifest[^>]*>([\s\S]*?)<\/manifest>/);
+  const manifestMap = {};
+  const manifestHrefToId = {};
+  if (manifestMatch) {
+    const itemRegex = /<item\s+([^>]+?)\/?>/g;
+    let itemMatch;
+    while ((itemMatch = itemRegex.exec(manifestMatch[1])) !== null) {
+      const attrs = itemMatch[1];
+      const id = getAttr(attrs, "id");
+      const href = getAttr(attrs, "href");
+      const mediaType = getAttr(attrs, "media-type") || "";
+      if (id && href) {
+        manifestMap[id] = { href, mediaType };
+        manifestHrefToId[href] = id;
+      }
+    }
+  }
+  const spineMatch = opfXml.match(/<spine[^>]*>([\s\S]*?)<\/spine>/);
+  const spineItems = [];
+  if (spineMatch) {
+    const itemrefRegex = /<itemref\s+([^>]+?)\/?>/g;
+    let refMatch;
+    while ((refMatch = itemrefRegex.exec(spineMatch[1])) !== null) {
+      const idref = getAttr(refMatch[1], "idref");
+      if (idref) spineItems.push(idref);
+    }
+  }
+  const spineTocAttr = spineMatch ? spineMatch[0].match(/toc="([^"]+)"/)?.[1] ?? null : null;
+  if (spineTocAttr) {
+    const tocInfo = manifestMap[spineTocAttr];
+    if (tocInfo) {
+      const tocPath = resolvePath(opfDir, tocInfo.href);
+      const tocFile = findZipFile(tocPath);
+      if (tocFile) {
+        let parseNavPoints2 = function(xml, parentPath) {
+          const items = [];
+          const navRegex = /<navPoint[^>]*>([\s\S]*?)<\/navPoint>/g;
+          let navMatch;
+          while ((navMatch = navRegex.exec(xml)) !== null) {
+            const block = navMatch[1];
+            const labelMatch = block.match(
+              /<navLabel[^>]*>[\s\S]*?<text>([^<]*)<\/text>/
+            );
+            const contentMatch = block.match(/<content\s+src="([^"]+)"/);
+            if (labelMatch && contentMatch) {
+              const src = contentMatch[1].split("#")[0];
+              const item = {
+                title: labelMatch[1].trim(),
+                src: resolvePath(parentPath, src)
+              };
+              const children = parseNavPoints2(block, parentPath);
+              if (children.length > 0) item.children = children;
+              items.push(item);
+            }
+          }
+          return items;
+        };
+        var parseNavPoints = parseNavPoints2;
+        const tocXml = await tocFile.async("string");
+        const parsed = parseNavPoints2(tocXml, opfDir);
+        toc.push(...parsed);
+      }
+    }
+  }
+  for (const [, info] of Object.entries(manifestMap)) {
+    if (info.mediaType === "text/css" || info.href.endsWith(".css")) {
+      const cssPath = resolvePath(opfDir, info.href);
+      const cssFile = findZipFile(cssPath);
+      if (cssFile) {
+        try {
+          const cssText = await cssFile.async("string");
+          stylesheets.push(cssText);
+        } catch {
+        }
+      }
+    }
+  }
+  const tocTitleMap = {};
+  function flattenToc(items) {
+    for (const item of items) {
+      if (item.title) {
+        tocTitleMap[item.src] = item.title;
+        const filename = item.src.split("/").pop();
+        tocTitleMap[filename] = item.title;
+      }
+      if (item.children) flattenToc(item.children);
+    }
+  }
+  flattenToc(toc);
+  for (let i = 0; i < spineItems.length; i++) {
+    const idref = spineItems[i];
+    const info = manifestMap[idref];
+    if (!info) continue;
+    const filePath = resolvePath(opfDir, info.href);
+    const chapterFile = findZipFile(filePath);
+    if (!chapterFile) continue;
+    const chapterXml = await chapterFile.async("string");
+    let chapterTitle = `Chapter ${i + 1}`;
+    const tocTitle = tocTitleMap[filePath] || tocTitleMap[filePath.toLowerCase()] || tocTitleMap[info.href] || tocTitleMap[info.href.toLowerCase()];
+    if (tocTitle) {
+      chapterTitle = tocTitle;
+    } else {
+      const hMatch = chapterXml.match(/<h[1-3][^>]*>([\s\S]*?)<\/h[1-3]>/);
+      if (hMatch && hMatch[1].trim()) {
+        chapterTitle = hMatch[1].replace(/<[^>]+>/g, "").trim();
+      } else {
+        const titleTagMatch = chapterXml.match(/<title>([^<]*)<\/title>/);
+        if (titleTagMatch && titleTagMatch[1].trim()) {
+          chapterTitle = titleTagMatch[1].trim();
+        }
+      }
+    }
+    const bodyMatch = chapterXml.match(/<body[^>]*>([\s\S]*?)<\/body>/);
+    let bodyHtml = bodyMatch ? bodyMatch[1] : chapterXml;
+    bodyHtml = bodyHtml.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<div\s+class="mbp_pagebreak"[^>]*><\/div>/gi, "");
+    const chapterDir = filePath.includes("/") ? filePath.substring(0, filePath.lastIndexOf("/") + 1) : "";
+    bodyHtml = bodyHtml.replace(
+      /(<img\s+[^>]*?)src="([^"]+)"/gi,
+      (_match, prefix, src) => {
+        if (src.startsWith("http://") || src.startsWith("https://") || src.startsWith("data:")) {
+          return `${prefix}src="${src}"`;
+        }
+        const resolvedSrc = resolvePath(chapterDir, src);
+        const blobUrl = imageMap[resolvedSrc] || imageMap[resolvedSrc.toLowerCase()] || imageMap[src] || imageMap[src.toLowerCase()] || imageMap[src.split("/").pop()] || imageMap[src.split("/").pop().toLowerCase()];
+        if (blobUrl) {
+          return `${prefix}src="${blobUrl}"`;
+        }
+        return `${prefix}src="${src}"`;
+      }
+    );
+    bodyHtml = bodyHtml.replace(
+      /(<a\s+[^>]*?)href="([^"]+)"/gi,
+      (_match, prefix, href) => {
+        if (href.startsWith("http://") || href.startsWith("https://") || href.startsWith("#") || href.startsWith("mailto:")) {
+          return `${prefix}href="${href}"`;
+        }
+        const resolvedHref = resolvePath(chapterDir, href.split("#")[0]);
+        const anchor = href.includes("#") ? "#" + href.split("#")[1] : "";
+        return `${prefix}href="${resolvedHref}${anchor}" data-epub-link="true"`;
+      }
+    );
+    chapters.push({
+      index: i,
+      title: chapterTitle,
+      htmlContent: bodyHtml,
+      filePath
+    });
+  }
+  if (chapters.length === 0) {
+    const htmlFiles = [];
+    zip.forEach((path) => {
+      if (path.endsWith(".html") || path.endsWith(".xhtml") || path.endsWith(".htm")) {
+        htmlFiles.push(path);
+      }
+    });
+    htmlFiles.sort();
+    for (let i = 0; i < htmlFiles.length; i++) {
+      const file = zip.file(htmlFiles[i]);
+      if (!file) continue;
+      const html = await file.async("string");
+      const bodyMatch = html.match(/<body[^>]*>([\s\S]*?)<\/body>/);
+      let bodyHtml = (bodyMatch ? bodyMatch[1] : html).replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<div\s+class="mbp_pagebreak"[^>]*><\/div>/gi, "");
+      const chapterDir = htmlFiles[i].includes("/") ? htmlFiles[i].substring(0, htmlFiles[i].lastIndexOf("/") + 1) : "";
+      bodyHtml = bodyHtml.replace(
+        /(<img\s+[^>]*?)src="([^"]+)"/gi,
+        (_match, prefix, src) => {
+          if (src.startsWith("http://") || src.startsWith("https://") || src.startsWith("data:")) {
+            return `${prefix}src="${src}"`;
+          }
+          const resolvedSrc = resolvePath(chapterDir, src);
+          const blobUrl = imageMap[resolvedSrc] || imageMap[resolvedSrc.toLowerCase()] || imageMap[src] || imageMap[src.toLowerCase()];
+          if (blobUrl) {
+            return `${prefix}src="${blobUrl}"`;
+          }
+          return `${prefix}src="${src}"`;
+        }
+      );
+      const tocTitle = tocTitleMap[htmlFiles[i]] || tocTitleMap[htmlFiles[i].toLowerCase()];
+      const hMatch = html.match(/<h[1-3][^>]*>([\s\S]*?)<\/h[1-3]>/);
+      let chTitle = `Chapter ${i + 1}`;
+      if (tocTitle) {
+        chTitle = tocTitle;
+      } else if (hMatch && hMatch[1].trim()) {
+        chTitle = hMatch[1].replace(/<[^>]+>/g, "").trim();
+      }
+      chapters.push({
+        index: i,
+        title: chTitle,
+        htmlContent: bodyHtml,
+        filePath: htmlFiles[i]
+      });
+    }
+  }
+  return { title: bookTitle, author: bookAuthor, chapters, toc, stylesheets, imageMap };
+}
+function EpubPreview({ content, fileName }) {
+  const [bookData, setBookData] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const [currentChapter, setCurrentChapter] = useState(0);
+  const [showToc, setShowToc] = useState(false);
+  const [showChapterDropdown, setShowChapterDropdown] = useState(false);
+  const [searchQuery, setSearchQuery] = useState("");
+  const [searchResults, setSearchResults] = useState([]);
+  const contentRef = useRef(null);
+  const dropdownRef = useRef(null);
+  const t = useLocale();
+  const [prevContent, setPrevContent] = useState(content);
+  if (prevContent !== content) {
+    setPrevContent(content);
+    setLoading(true);
+    setError(null);
+    setBookData(null);
+    setCurrentChapter(0);
+    setSearchResults([]);
+  }
+  useEffect(() => {
+    let cancelled = false;
+    parseEpub(content).then(
+      (result) => {
+        if (cancelled) return;
+        setBookData(result);
+        setLoading(false);
+      },
+      (err) => {
+        if (cancelled) return;
+        console.error("Error parsing EPUB:", err);
+        setError(err instanceof Error ? err.message : "Failed to parse e-book");
+        setLoading(false);
+      }
+    );
+    return () => {
+      cancelled = true;
+    };
+  }, [content]);
+  useEffect(() => {
+    function handleClickOutside(e) {
+      if (dropdownRef.current && !dropdownRef.current.contains(e.target)) {
+        setShowChapterDropdown(false);
+      }
+    }
+    document.addEventListener("mousedown", handleClickOutside);
+    return () => document.removeEventListener("mousedown", handleClickOutside);
+  }, []);
+  useEffect(() => {
+    return () => {
+      if (bookData?.imageMap) {
+        Object.values(bookData.imageMap).forEach((url) => {
+          if (url.startsWith("blob:")) URL.revokeObjectURL(url);
+        });
+      }
+    };
+  }, [bookData?.imageMap]);
+  useEffect(() => {
+    if (contentRef.current) {
+      contentRef.current.scrollTop = 0;
+    }
+  }, [currentChapter]);
+  const handleSearch = useCallback(
+    (query) => {
+      setSearchQuery(query);
+      if (!bookData || !query.trim()) {
+        setSearchResults([]);
+        return;
+      }
+      const lowerQuery = query.toLowerCase();
+      const results = [];
+      for (let i = 0; i < bookData.chapters.length; i++) {
+        const text = bookData.chapters[i].htmlContent.replace(/<[^>]+>/g, "");
+        const idx = text.toLowerCase().indexOf(lowerQuery);
+        if (idx !== -1) {
+          const start = Math.max(0, idx - 30);
+          const end = Math.min(text.length, idx + query.length + 30);
+          const snippet = (start > 0 ? "..." : "") + text.substring(start, end) + (end < text.length ? "..." : "");
+          results.push({ chapterIndex: i, snippet });
+          if (results.length >= 20) break;
+        }
+      }
+      setSearchResults(results);
+    },
+    [bookData]
+  );
+  const handleContentClick = useCallback(
+    (e) => {
+      const target = e.target;
+      const anchor = target.closest("a");
+      if (!anchor || !bookData) return;
+      const isEpubLink = anchor.getAttribute("data-epub-link") === "true";
+      if (isEpubLink) {
+        e.preventDefault();
+        const href = anchor.getAttribute("href") || "";
+        const targetPath = href.split("#")[0];
+        const chapterIdx = bookData.chapters.findIndex(
+          (ch) => ch.filePath === targetPath || ch.filePath.toLowerCase() === targetPath.toLowerCase()
+        );
+        if (chapterIdx !== -1) {
+          setCurrentChapter(chapterIdx);
+          setTimeout(() => {
+            if (contentRef.current) contentRef.current.scrollTop = 0;
+          }, 100);
+        }
+      }
+    },
+    [bookData]
+  );
+  if (loading) {
+    return /* @__PURE__ */ jsxs("div", { className: "fv-epub__state fv-epub__state--loading", children: [
+      /* @__PURE__ */ jsx("div", { className: "fv-spinner fv-spinner--lg" }),
+      /* @__PURE__ */ jsx("p", { className: "fv-epub__state-msg", children: t.loadingEbook })
+    ] });
+  }
+  if (error || !bookData) {
+    return /* @__PURE__ */ jsxs("div", { className: "fv-epub__state fv-epub__state--error", children: [
+      /* @__PURE__ */ jsx(BookOpenIcon, { size: 48, className: "fv-epub__state-icon" }),
+      /* @__PURE__ */ jsx("p", { className: "fv-epub__state-title", children: t.ebookLoadFailed }),
+      /* @__PURE__ */ jsx("p", { className: "fv-epub__state-msg", children: error || t.unknownError })
+    ] });
+  }
+  if (bookData.chapters.length === 0) {
+    return /* @__PURE__ */ jsxs("div", { className: "fv-epub__state fv-epub__state--empty", children: [
+      /* @__PURE__ */ jsx(BookOpenIcon, { size: 48 }),
+      /* @__PURE__ */ jsx("p", { className: "fv-epub__state-title", children: t.noChaptersFound })
+    ] });
+  }
+  const chapter = bookData.chapters[currentChapter];
+  const combinedCss = bookData.stylesheets.join("\n") + `
+    /* Override book styles that may cause horizontal overflow */
+    .fv-epub__article * {
+      max-width: 100% !important;
+      overflow-wrap: break-word !important;
+      word-wrap: break-word !important;
+    }
+    .fv-epub__article pre, .fv-epub__article code {
+      overflow-x: auto !important;
+      max-width: 100% !important;
+    }
+    .fv-epub__article img {
+      max-width: 100% !important;
+      height: auto !important;
+    }
+    .fv-epub__article table {
+      display: block;
+      overflow-x: auto;
+      max-width: 100%;
+    }
+  `;
+  return /* @__PURE__ */ jsxs("div", { className: "fv-epub", children: [
+    /* @__PURE__ */ jsx("div", { className: "fv-epub__info-bar", children: /* @__PURE__ */ jsxs("div", { className: "fv-epub__info-row", children: [
+      /* @__PURE__ */ jsxs("div", { className: "fv-epub__info-left", children: [
+        /* @__PURE__ */ jsx(BookOpenIcon, { size: 14, className: "fv-epub__info-icon" }),
+        /* @__PURE__ */ jsx("span", { className: "fv-epub__info-title", children: bookData.title || fileName }),
+        bookData.author && /* @__PURE__ */ jsxs("span", { className: "fv-epub__info-author", children: [
+          "\u2014 ",
+          bookData.author
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "fv-epub__info-right", children: [
+        /* @__PURE__ */ jsxs("div", { className: "fv-epub__search-wrap", children: [
+          /* @__PURE__ */ jsx(SearchIcon, { size: 14, className: "fv-epub__search-icon" }),
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              type: "text",
+              value: searchQuery,
+              onChange: (e) => handleSearch(e.target.value),
+              placeholder: t.searchPlaceholder,
+              className: "fv-epub__search-input"
+            }
+          ),
+          searchQuery && /* @__PURE__ */ jsx(
+            "button",
+            {
+              onClick: () => {
+                setSearchQuery("");
+                setSearchResults([]);
+              },
+              className: "fv-epub__search-clear",
+              children: /* @__PURE__ */ jsx(XIcon, { size: 12 })
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            onClick: () => setShowToc(!showToc),
+            className: `fv-epub__toc-btn ${showToc ? "fv-epub__toc-btn--active" : ""}`,
+            title: t.tableOfContents,
+            children: /* @__PURE__ */ jsx(ListIcon, { size: 16 })
+          }
+        )
+      ] })
+    ] }) }),
+    searchQuery && searchResults.length > 0 && /* @__PURE__ */ jsxs("div", { className: "fv-epub__search-results", children: [
+      /* @__PURE__ */ jsx("p", { className: "fv-epub__search-results-label", children: t.foundInChapters.replace("{count}", searchResults.length.toLocaleString()) }),
+      /* @__PURE__ */ jsx("div", { className: "fv-epub__search-results-list", children: searchResults.map((r, i) => /* @__PURE__ */ jsxs(
+        "button",
+        {
+          onClick: () => {
+            setCurrentChapter(r.chapterIndex);
+            setSearchQuery("");
+            setSearchResults([]);
+          },
+          className: "fv-epub__search-result-item",
+          children: [
+            /* @__PURE__ */ jsx("span", { className: "fv-epub__search-result-title", children: bookData.chapters[r.chapterIndex].title }),
+            /* @__PURE__ */ jsx("span", { className: "fv-epub__search-result-snippet", children: r.snippet })
+          ]
+        },
+        i
+      )) })
+    ] }),
+    searchQuery && searchResults.length === 0 && /* @__PURE__ */ jsx("div", { className: "fv-epub__search-empty", children: /* @__PURE__ */ jsx("p", { className: "fv-epub__search-empty-text", children: t.noResultsFound }) }),
+    /* @__PURE__ */ jsxs("div", { className: "fv-epub__body", children: [
+      showToc && /* @__PURE__ */ jsx("div", { className: "fv-epub__toc-sidebar", children: /* @__PURE__ */ jsxs("div", { className: "fv-epub__toc-inner", children: [
+        /* @__PURE__ */ jsx("h3", { className: "fv-epub__toc-heading", children: t.tableOfContents }),
+        /* @__PURE__ */ jsx(
+          TocTree,
+          {
+            items: bookData.toc,
+            chapters: bookData.chapters,
+            currentChapter,
+            onSelect: (idx) => {
+              setCurrentChapter(idx);
+              setShowChapterDropdown(false);
+            }
+          }
+        ),
+        bookData.toc.length === 0 && /* @__PURE__ */ jsx("div", { className: "fv-epub__toc-list", children: bookData.chapters.map((ch, i) => /* @__PURE__ */ jsx(
+          "button",
+          {
+            onClick: () => setCurrentChapter(i),
+            className: `fv-epub__toc-item ${i === currentChapter ? "fv-epub__toc-item--active" : ""}`,
+            children: ch.title
+          },
+          i
+        )) })
+      ] }) }),
+      /* @__PURE__ */ jsxs("div", { className: "fv-epub__main", children: [
+        /* @__PURE__ */ jsxs("div", { className: "fv-epub__chapter-bar", children: [
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              onClick: () => setCurrentChapter(Math.max(0, currentChapter - 1)),
+              disabled: currentChapter === 0,
+              className: "fv-epub__chapter-nav-btn",
+              children: /* @__PURE__ */ jsx(ChevronLeftIcon, { size: 16 })
+            }
+          ),
+          /* @__PURE__ */ jsxs("div", { className: "fv-epub__dropdown-wrap", ref: dropdownRef, children: [
+            /* @__PURE__ */ jsxs(
+              "button",
+              {
+                onClick: () => setShowChapterDropdown(!showChapterDropdown),
+                className: "fv-epub__dropdown-trigger",
+                children: [
+                  /* @__PURE__ */ jsxs("span", { className: "fv-epub__dropdown-index", children: [
+                    currentChapter + 1,
+                    "/",
+                    bookData.chapters.length
+                  ] }),
+                  /* @__PURE__ */ jsx("span", { className: "fv-epub__dropdown-title", children: chapter.title }),
+                  /* @__PURE__ */ jsx(
+                    ChevronDownIcon,
+                    {
+                      size: 14,
+                      className: `fv-epub__dropdown-chevron ${showChapterDropdown ? "fv-epub__dropdown-chevron--open" : ""}`
+                    }
+                  )
+                ]
+              }
+            ),
+            showChapterDropdown && /* @__PURE__ */ jsx("div", { className: "fv-epub__dropdown-list", children: bookData.chapters.map((ch, i) => /* @__PURE__ */ jsxs(
+              "button",
+              {
+                onClick: () => {
+                  setCurrentChapter(i);
+                  setShowChapterDropdown(false);
+                },
+                className: `fv-epub__dropdown-item ${i === currentChapter ? "fv-epub__dropdown-item--active" : ""}`,
+                children: [
+                  /* @__PURE__ */ jsxs("span", { className: "fv-epub__dropdown-item-index", children: [
+                    i + 1,
+                    "."
+                  ] }),
+                  ch.title
+                ]
+              },
+              i
+            )) })
+          ] }),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              onClick: () => setCurrentChapter(Math.min(bookData.chapters.length - 1, currentChapter + 1)),
+              disabled: currentChapter === bookData.chapters.length - 1,
+              className: "fv-epub__chapter-nav-btn",
+              children: /* @__PURE__ */ jsx(ChevronRightIcon, { size: 16 })
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx("div", { className: "fv-epub__content", ref: contentRef, onClick: handleContentClick, children: /* @__PURE__ */ jsxs("div", { className: "fv-epub__content-inner", children: [
+          /* @__PURE__ */ jsx("h2", { className: "fv-epub__chapter-title", children: chapter.title }),
+          combinedCss && /* @__PURE__ */ jsx("style", { dangerouslySetInnerHTML: { __html: combinedCss } }),
+          /* @__PURE__ */ jsx(
+            "div",
+            {
+              className: "fv-epub__article",
+              dangerouslySetInnerHTML: { __html: chapter.htmlContent }
+            }
+          )
+        ] }) }),
+        /* @__PURE__ */ jsxs("div", { className: "fv-epub__footer", children: [
+          /* @__PURE__ */ jsxs(
+            "button",
+            {
+              onClick: () => setCurrentChapter(Math.max(0, currentChapter - 1)),
+              disabled: currentChapter === 0,
+              className: "fv-epub__footer-btn",
+              children: [
+                /* @__PURE__ */ jsx(ChevronLeftIcon, { size: 16 }),
+                /* @__PURE__ */ jsx("span", { className: "fv-epub__footer-btn-text", children: t.previous })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxs("span", { className: "fv-epub__footer-label", children: [
+            currentChapter + 1,
+            " / ",
+            bookData.chapters.length
+          ] }),
+          /* @__PURE__ */ jsxs(
+            "button",
+            {
+              onClick: () => setCurrentChapter(Math.min(bookData.chapters.length - 1, currentChapter + 1)),
+              disabled: currentChapter === bookData.chapters.length - 1,
+              className: "fv-epub__footer-btn",
+              children: [
+                /* @__PURE__ */ jsx("span", { className: "fv-epub__footer-btn-text", children: t.next }),
+                /* @__PURE__ */ jsx(ChevronRightIcon, { size: 16 })
+              ]
+            }
+          )
+        ] })
+      ] })
+    ] })
+  ] });
+}
+function TocTree({
+  items,
+  chapters,
+  currentChapter,
+  onSelect,
+  depth = 0
+}) {
+  return /* @__PURE__ */ jsx("div", { className: depth > 0 ? "fv-epub__toc-indent" : "fv-epub__toc-list", children: items.map((item, i) => {
+    const chapterIdx = chapters.findIndex(
+      (ch) => ch.filePath === item.src || ch.filePath.toLowerCase() === item.src.toLowerCase() || item.src.endsWith(ch.filePath.split("/").pop()) || ch.filePath.endsWith(item.src.split("/").pop())
+    );
+    const isCurrent = chapterIdx === currentChapter;
+    return /* @__PURE__ */ jsxs("div", { children: [
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          onClick: () => {
+            if (chapterIdx !== -1) onSelect(chapterIdx);
+          },
+          disabled: chapterIdx === -1,
+          className: `fv-epub__toc-item ${isCurrent ? "fv-epub__toc-item--active" : ""}`,
+          style: { paddingLeft: `${8 + depth * 4}px` },
+          children: item.title
+        }
+      ),
+      item.children && item.children.length > 0 && /* @__PURE__ */ jsx(
+        TocTree,
+        {
+          items: item.children,
+          chapters,
+          currentChapter,
+          onSelect,
+          depth: depth + 1
+        }
+      )
+    ] }, `${depth}-${i}`);
+  }) });
+}
+export {
+  EpubPreview
+};
+//# sourceMappingURL=EpubPreview.js.map