@papyrus-sdk/engine-epub 0.2.5 → 0.2.7

package/dist/index.js

@@ -27,24 +27,55 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // index.ts
-var index_exports = {};
-__export(index_exports, {
+var engine_epub_exports = {};
+__export(engine_epub_exports, {
   EPUBEngine: () => EPUBEngine
 });
-module.exports = __toCommonJS(index_exports);
+module.exports = __toCommonJS(engine_epub_exports);
 var import_epubjs = __toESM(require("epubjs"));
 var import_core = require("@papyrus-sdk/core");
-var EPUBEngine = class extends import_core.BaseDocumentEngine {
+var EPUBEngine = class _EPUBEngine extends import_core.BaseDocumentEngine {
   constructor() {
     super(...arguments);
     this.book = null;
     this.spineItems = [];
-    this.renditions = /* @__PURE__ */ new Map();
-    this.renditionTargets = /* @__PURE__ */ new Map();
+    this.coverUrl = null;
+    this.readerRendition = null;
+    this.readerTarget = null;
     this.pageSizes = /* @__PURE__ */ new Map();
     this.currentPage = 1;
     this.zoom = 1;
     this.rotation = 0;
+    this.heightSyncVersion = 0;
+    this.renderVersion = 0;
+    this.renderLock = Promise.resolve();
+    this.pendingHrefDestination = null;
+    this.destinationSequence = [];
+    this.destinationCursor = -1;
+    this.lastDestinationNavTime = 0;
+    this.lastDestinationPageIndex = null;
+    this.lastDestinationHref = null;
+  }
+  static {
+    this.A4_RATIO = 1.4142;
+  }
+  static {
+    this.USE_INTERNAL_IFRAME_SCROLL = true;
+  }
+  static {
+    this.MOBILE_VIEWPORT_MAX_WIDTH_PX = 768;
+  }
+  static {
+    this.MOBILE_SHORT_VIEWPORT_MAX_HEIGHT_PX = 500;
+  }
+  static {
+    this.INTERNAL_VIEWPORT_PADDING_PX = 10;
+  }
+  static {
+    this.MAX_SECTION_HEIGHT = 1e6;
+  }
+  static {
+    this.HEIGHT_PADDING = 24;
   }
   getRenderTargetType() {
     return "element";
@@ -53,34 +84,243 @@ var EPUBEngine = class extends import_core.BaseDocumentEngine {
     try {
       const { source, type } = this.normalizeLoadInput(input);
       if (type && type !== "epub") {
-        throw new Error(`[EPUBEngine] Tipo de documento n\xE3o suportado: ${type}`);
+        throw new Error(
+          `[EPUBEngine] Tipo de documento n\xE3o suportado: ${type}`
+        );
       }
+      this.renderVersion += 1;
+      this.renderLock = Promise.resolve();
+      this.disposeReader();
+      this.pageSizes.clear();
+      this.spineItems = [];
+      this.coverUrl = null;
+      this.destinationSequence = [];
+      this.destinationCursor = -1;
+      this.lastDestinationNavTime = 0;
+      this.lastDestinationPageIndex = null;
+      this.lastDestinationHref = null;
+      if (this.book?.destroy) this.book.destroy();
       const data = await this.resolveSource(source);
       this.book = (0, import_epubjs.default)(data);
+      if (this.book?.opened) {
+        await this.book.opened;
+      }
       await this.book.ready;
-      this.spineItems = this.book.spine?.items ?? [];
+      const packaging = this.book?.package ?? this.book?.packaging ?? null;
+      if (!packaging) {
+        throw new Error("[EPUBEngine] packaging indisponivel.");
+      }
+      if (!this.book.package) {
+        this.book.package = packaging;
+      }
+      if (!this.book.packaging) {
+        this.book.packaging = packaging;
+      }
+      if (this.book?.loaded?.navigation) {
+        await this.book.loaded.navigation;
+      }
+      this.spineItems = this.getLinearSpineItems(this.book.spine?.items ?? []);
+      if (typeof this.book.coverUrl === "function") {
+        try {
+          const resolvedCover = await this.book.coverUrl();
+          if (typeof resolvedCover === "string" && resolvedCover.length > 0) {
+            this.coverUrl = resolvedCover;
+          }
+        } catch {
+          this.coverUrl = null;
+        }
+      }
       this.currentPage = 1;
-      this.renditions.forEach((rendition) => rendition?.destroy?.());
-      this.renditions.clear();
-      this.renditionTargets.clear();
-      this.pageSizes.clear();
     } catch (error) {
       console.error("[EPUBEngine] Erro ao carregar:", error);
       throw error;
     }
   }
   getPageCount() {
-    return this.spineItems.length;
+    return this.spineItems.length + (this.hasCoverPage() ? 1 : 0);
   }
   getCurrentPage() {
     return this.currentPage;
   }
   goToPage(page) {
-    if (page >= 1 && page <= this.getPageCount()) this.currentPage = page;
+    if (page < 1 || page > this.getPageCount()) return;
+    this.currentPage = page;
+    this.pendingHrefDestination = null;
+    if (this.destinationSequence.length) {
+      const destinationIndex = this.findNearestDestinationIndexByPage(page - 1);
+      if (destinationIndex >= 0) this.destinationCursor = destinationIndex;
+    }
+  }
+  async goToDestination(dest) {
+    const href = this.extractHrefDestination(dest);
+    if (!href) {
+      const pageIndex = await this.getPageIndex(dest);
+      if (pageIndex != null) this.goToPage(pageIndex + 1);
+      return pageIndex;
+    }
+    const baseHref = this.normalizeHref(href);
+    const currentBaseHref = this.lastDestinationHref ? this.normalizeHref(this.lastDestinationHref) : null;
+    const hasAnchor = href.includes("#");
+    if (!hasAnchor && currentBaseHref && baseHref === currentBaseHref && this.readerRendition) {
+      this.debugLog("goToDestination:skip-same-base", {
+        href,
+        currentBaseHref
+      });
+      const pageIndex = await this.resolvePageIndexFromHref(href);
+      return pageIndex;
+    }
+    let releaseCurrent = null;
+    const previousRender = this.renderLock;
+    this.renderLock = new Promise((resolve) => {
+      releaseCurrent = resolve;
+    });
+    await previousRender;
+    try {
+      this.pendingHrefDestination = href;
+      let pageIndex = await this.resolvePageIndexFromHref(href);
+      if (pageIndex != null) this.currentPage = pageIndex + 1;
+      this.debugLog("goToDestination:start", {
+        href,
+        pageIndex,
+        currentPage: this.currentPage
+      });
+      const rendition = this.readerRendition;
+      let displayFailed = false;
+      if (rendition) {
+        try {
+          const didDisplay = await this.displayDestinationWithRetry(
+            rendition,
+            href
+          );
+          if (!didDisplay)
+            throw new Error("Destination display retry exhausted");
+          if (pageIndex == null) {
+            const locationPageIndex = this.getPageIndexFromRenditionLocation(rendition);
+            if (locationPageIndex != null) {
+              pageIndex = locationPageIndex;
+              this.currentPage = locationPageIndex + 1;
+            }
+          }
+          this.debugLog("goToDestination:displayed", {
+            href,
+            pageIndex,
+            currentPage: this.currentPage
+          });
+          this.updateDestinationCursor(href, pageIndex);
+          this.pendingHrefDestination = null;
+          this.lastDestinationNavTime = Date.now();
+          this.lastDestinationPageIndex = pageIndex;
+          this.lastDestinationHref = href;
+          return pageIndex;
+        } catch {
+          displayFailed = true;
+          this.debugLog("goToDestination:display-failed", { href, pageIndex });
+        }
+      }
+      if (displayFailed && pageIndex != null && this.readerTarget && typeof this.readerTarget.isConnected === "boolean" && this.readerTarget.isConnected) {
+        void this.renderPage(pageIndex, this.readerTarget, 1).catch(() => {
+        });
+      }
+      this.debugLog("goToDestination:no-rendition", {
+        href,
+        pageIndex,
+        currentPage: this.currentPage
+      });
+      this.updateDestinationCursor(href, pageIndex);
+      return pageIndex;
+    } finally {
+      releaseCurrent?.();
+    }
+  }
+  async goToAdjacentDestination(delta) {
+    if (!Number.isFinite(delta) || delta === 0) return this.currentPage - 1;
+    await this.ensureDestinationSequence();
+    if (!this.destinationSequence.length) {
+      const basePageIndex = Math.max(0, this.currentPage - 1);
+      const nextPageIndex = Math.max(
+        0,
+        Math.min(this.getPageCount() - 1, basePageIndex + (delta > 0 ? 1 : -1))
+      );
+      if (nextPageIndex === basePageIndex) return basePageIndex;
+      this.goToPage(nextPageIndex + 1);
+      return nextPageIndex;
+    }
+    if (this.destinationCursor < 0) {
+      const inferred = this.findNearestDestinationIndexByPage(
+        this.currentPage - 1
+      );
+      this.destinationCursor = inferred >= 0 ? inferred : 0;
+    }
+    const currentEntry = this.destinationSequence[this.destinationCursor];
+    const currentBaseHref = currentEntry ? this.normalizeHref(currentEntry.href) : null;
+    this.debugLog("goToAdjacentDestination:start", {
+      delta,
+      cursor: this.destinationCursor,
+      total: this.destinationSequence.length,
+      currentPage: this.currentPage,
+      currentBaseHref
+    });
+    const step = delta > 0 ? 1 : -1;
+    let nextIndex = this.destinationCursor;
+    const limit = delta > 0 ? this.destinationSequence.length - 1 : 0;
+    while (true) {
+      const candidate = nextIndex + step;
+      if (candidate < 0 || candidate > this.destinationSequence.length - 1)
+        break;
+      nextIndex = candidate;
+      const candidateBaseHref = this.normalizeHref(
+        this.destinationSequence[nextIndex].href
+      );
+      if (!currentBaseHref || candidateBaseHref !== currentBaseHref) break;
+    }
+    if (nextIndex === this.destinationCursor) {
+      this.debugLog("goToAdjacentDestination:at-boundary", {
+        delta,
+        cursor: this.destinationCursor
+      });
+      const current = this.destinationSequence[this.destinationCursor];
+      return current?.pageIndex ?? this.currentPage - 1;
+    }
+    const target = this.destinationSequence[nextIndex];
+    if (!target) return null;
+    this.destinationCursor = nextIndex;
+    const resolved = await this.goToDestination({
+      kind: "href",
+      value: target.href
+    });
+    if (resolved != null) {
+      this.debugLog("goToAdjacentDestination:resolved", {
+        delta,
+        nextIndex,
+        href: target.href,
+        resolved
+      });
+      return resolved;
+    }
+    this.destinationCursor = nextIndex - step;
+    this.debugLog("goToAdjacentDestination:failed", {
+      delta,
+      nextIndex,
+      href: target.href
+    });
+    return null;
+  }
+  getDestinationNavigationState() {
+    const total = this.destinationSequence.length;
+    if (!total) {
+      return {
+        hasPrev: this.currentPage > 1,
+        hasNext: this.currentPage < this.getPageCount()
+      };
+    }
+    const cursor = this.destinationCursor >= 0 ? this.destinationCursor : this.findNearestDestinationIndexByPage(this.currentPage - 1);
+    return {
+      hasPrev: cursor > 0,
+      hasNext: cursor >= 0 && cursor < total - 1
+    };
   }
   setZoom(zoom) {
     this.zoom = Math.max(0.5, Math.min(3, zoom));
-    this.renditions.forEach((rendition) => this.applyRenditionTheme(rendition));
   }
   getZoom() {
     return this.zoom;
@@ -101,74 +341,184 @@ var EPUBEngine = class extends import_core.BaseDocumentEngine {
     return { width: 0, height: 0 };
   }
   async selectText(pageIndex, rect) {
-    void pageIndex;
-    void rect;
     return null;
   }
   async renderPage(pageIndex, target, scale) {
-    const scaleKey = Math.round(scale * 1e3);
-    const element = target;
-    if (!this.book || !element) return;
-    const spineItem = this.spineItems[pageIndex];
-    if (!spineItem) return;
-    const width = element.clientWidth > 0 ? element.clientWidth : 640;
-    const height = element.clientHeight > 0 ? element.clientHeight : 900;
-    element.style.width = `${width}px`;
-    element.style.height = `${height}px`;
-    if (width >= 320 && height >= 480) this.pageSizes.set(pageIndex, { width, height });
-    const renditionKey = `${pageIndex}:${scaleKey}`;
-    let rendition = this.renditions.get(renditionKey);
-    const currentTarget = this.renditionTargets.get(renditionKey);
-    if (!rendition || currentTarget !== element) {
-      if (rendition?.destroy) rendition.destroy();
-      element.innerHTML = "";
-      rendition = this.book.renderTo(element, {
-        width,
-        height,
-        flow: "paginated",
-        spread: "none"
-      });
-      this.renditions.set(renditionKey, rendition);
-      this.renditionTargets.set(renditionKey, element);
-      if (rendition?.hooks?.content?.register) {
-        rendition.hooks.content.register((contents) => {
-          const frame = contents?.document?.defaultView?.frameElement;
-          if (frame) {
-            frame.setAttribute("sandbox", "allow-scripts allow-same-origin");
+    let releaseCurrent = null;
+    const previousRender = this.renderLock;
+    this.renderLock = new Promise((resolve) => {
+      releaseCurrent = resolve;
+    });
+    await previousRender;
+    try {
+      const pageCount = this.getPageCount();
+      if (pageCount <= 0) return;
+      const safePageIndex = Math.max(0, Math.min(pageCount - 1, pageIndex));
+      const renderVersion = ++this.renderVersion;
+      const element = target;
+      if (!this.book || !element) return;
+      const width = element.clientWidth > 0 ? element.clientWidth : 640;
+      const viewportHeightHint = _EPUBEngine.USE_INTERNAL_IFRAME_SCROLL ? this.getViewportHeightHint(element) : null;
+      const rawHeight = viewportHeightHint ?? (element.clientHeight > 0 ? element.clientHeight : 900);
+      const normalizedHeight = _EPUBEngine.USE_INTERNAL_IFRAME_SCROLL ? Math.max(360, Math.min(4e3, rawHeight)) : Math.max(480, Math.min(1400, rawHeight));
+      const minA4Height = _EPUBEngine.USE_INTERNAL_IFRAME_SCROLL ? 0 : this.getA4MinHeight(width);
+      const seedHeight = _EPUBEngine.USE_INTERNAL_IFRAME_SCROLL ? normalizedHeight : Math.max(minA4Height, normalizedHeight);
+      if (this.isCoverPage(safePageIndex)) {
+        this.renderCoverPage(element, width, seedHeight, safePageIndex);
+        if (renderVersion === this.renderVersion) {
+          this.currentPage = safePageIndex + 1;
+        }
+        return;
+      }
+      const spineItem = this.getSpineItemForPage(safePageIndex);
+      if (!spineItem) return;
+      const displayTargets = [...this.getDisplayTargetsForSpineItem(spineItem)];
+      if (!displayTargets.length) return;
+      const defaultSectionIndex = typeof spineItem.index === "number" ? spineItem.index : null;
+      const pendingHrefDestination = this.pendingHrefDestination;
+      let consumedPendingHref = false;
+      if (pendingHrefDestination) {
+        const pendingPageIndex = await this.resolvePageIndexFromHref(
+          pendingHrefDestination
+        );
+        const pendingMatchesCurrentPage = pendingPageIndex === safePageIndex || this.isHrefMatchingSpineItem(pendingHrefDestination, spineItem);
+        if (pendingMatchesCurrentPage) {
+          consumedPendingHref = true;
+          displayTargets.unshift(
+            pendingHrefDestination,
+            this.decodeHref(pendingHrefDestination)
+          );
+        }
+      }
+      const uniqueTargets = this.uniqueDisplayTargets(displayTargets);
+      if (!uniqueTargets.length) return;
+      element.style.width = `${width}px`;
+      element.style.height = `${seedHeight}px`;
+      if (width >= 320 && seedHeight >= 480)
+        this.pageSizes.set(safePageIndex, { width, height: seedHeight });
+      let rendition = this.readerRendition;
+      if (!rendition || this.readerTarget !== element) {
+        this.disposeReader();
+        element.innerHTML = "";
+        rendition = this.createRendition(element, width, seedHeight);
+        this.readerRendition = rendition;
+        this.readerTarget = element;
+      } else if (typeof rendition.resize === "function" && rendition.manager?.resize) {
+        try {
+          rendition.resize(width, seedHeight);
+        } catch (error) {
+          this.disposeReader();
+          element.innerHTML = "";
+          rendition = this.createRendition(element, width, seedHeight);
+          this.readerRendition = rendition;
+          this.readerTarget = element;
+        }
+      }
+      if (rendition) {
+        const syncVersion = ++this.heightSyncVersion;
+        this.applyRenditionTheme(rendition);
+        if (renderVersion !== this.renderVersion) return;
+        const recentDestNav = Date.now() - this.lastDestinationNavTime < 200 && this.lastDestinationPageIndex === safePageIndex;
+        if (recentDestNav) {
+          this.debugLog("renderPage:skip-recent-dest-nav", {
+            safePageIndex,
+            msSince: Date.now() - this.lastDestinationNavTime
+          });
+          await this.syncSectionHeight(
+            rendition,
+            element,
+            safePageIndex,
+            width,
+            seedHeight,
+            defaultSectionIndex,
+            true
+          );
+          if (renderVersion !== this.renderVersion) return;
+          this.scheduleHeightSync(
+            syncVersion,
+            rendition,
+            element,
+            safePageIndex,
+            width,
+            seedHeight,
+            defaultSectionIndex,
+            true
+          );
+          if (renderVersion === this.renderVersion) {
+            this.currentPage = safePageIndex + 1;
           }
-        });
+        } else {
+          const sectionIndex = await this.displayWithFallback(
+            rendition,
+            uniqueTargets,
+            () => renderVersion !== this.renderVersion
+          );
+          if (sectionIndex === void 0) return;
+          if (renderVersion !== this.renderVersion) return;
+          if (consumedPendingHref && pendingHrefDestination && pendingHrefDestination.includes("#")) {
+            const anchored = await this.displayDestinationWithRetry(
+              rendition,
+              pendingHrefDestination
+            );
+            this.debugLog("renderPage:anchor-second-pass", {
+              href: pendingHrefDestination,
+              anchored
+            });
+            if (renderVersion !== this.renderVersion) return;
+          }
+          await this.syncSectionHeight(
+            rendition,
+            element,
+            safePageIndex,
+            width,
+            seedHeight,
+            sectionIndex ?? defaultSectionIndex
+          );
+          if (renderVersion !== this.renderVersion) return;
+          this.scheduleHeightSync(
+            syncVersion,
+            rendition,
+            element,
+            safePageIndex,
+            width,
+            seedHeight,
+            sectionIndex ?? defaultSectionIndex
+          );
+          if (renderVersion === this.renderVersion) {
+            if (consumedPendingHref) this.pendingHrefDestination = null;
+            this.currentPage = safePageIndex + 1;
+          }
+        }
       }
-    } else if (typeof rendition.resize === "function") {
-      rendition.resize(width, height);
-    }
-    if (rendition) {
-      this.applyRenditionTheme(rendition);
-      const targetRef = spineItem.href || spineItem.idref || spineItem.cfiBase || pageIndex;
-      await rendition.display(targetRef);
+    } finally {
+      releaseCurrent?.();
     }
   }
   async renderTextLayer(pageIndex, container, scale) {
-    void pageIndex;
-    void scale;
     const element = container;
     if (element) element.innerHTML = "";
   }
   async getTextContent(pageIndex) {
     if (!this.book) return [];
-    const spineItem = this.spineItems[pageIndex];
+    if (this.isCoverPage(pageIndex)) return [];
+    const spineIndex = this.toSpineIndex(pageIndex);
+    if (spineIndex < 0) return [];
+    const spineItem = this.spineItems[spineIndex];
     if (!spineItem) return [];
     try {
       const section = this.book.spine.get(spineItem.idref || spineItem.href);
       const text = typeof section?.text === "function" ? await section.text() : "";
       if (!text) return [];
-      return [{
-        str: text,
-        dir: "ltr",
-        width: 0,
-        height: 0,
-        transform: [1, 0, 0, 1, 0, 0],
-        fontName: "default"
-      }];
+      return [
+        {
+          str: text,
+          dir: "ltr",
+          width: 0,
+          height: 0,
+          transform: [1, 0, 0, 1, 0, 0],
+          fontName: "default"
+        }
+      ];
     } catch {
       return [];
     }
@@ -178,36 +528,53 @@ var EPUBEngine = class extends import_core.BaseDocumentEngine {
     const nav = await this.book.loaded?.navigation;
     const toc = nav?.toc ?? [];
     if (!toc.length) return [];
-    const mapItem = (item) => {
+    await this.ensureDestinationSequence();
+    const mapItem = async (item) => {
       const title = item.label || item.title || "";
-      const pageIndex = this.getSpineIndexByHref(item.href || "");
-      const children = Array.isArray(item.subitems) ? item.subitems.map(mapItem) : [];
+      const href = item.href || "";
+      const resolvedIndex = await this.resolvePageIndexFromHref(href);
+      const pageIndex = resolvedIndex ?? -1;
+      const children = Array.isArray(item.subitems) ? await Promise.all(item.subitems.map(mapItem)) : [];
       const outlineItem = { title, pageIndex };
+      if (href) {
+        outlineItem.dest = { kind: "href", value: href };
+      }
       if (children.length > 0) outlineItem.children = children;
       return outlineItem;
     };
-    return toc.map(mapItem);
+    return await Promise.all(toc.map(mapItem));
   }
   async getPageIndex(dest) {
     if (!dest) return null;
-    if (typeof dest === "string") return this.getSpineIndexByHref(dest);
-    if (dest.kind === "href") return this.getSpineIndexByHref(dest.value);
-    if (dest.kind === "pageIndex") return dest.value;
-    if (dest.kind === "pageNumber") return Math.max(0, dest.value - 1);
+    if (typeof dest === "string")
+      return await this.resolvePageIndexFromHref(dest);
+    if (dest.kind === "href")
+      return await this.resolvePageIndexFromHref(dest.value);
+    if (dest.kind === "pageIndex")
+      return Math.max(0, Math.min(this.getPageCount() - 1, dest.value));
+    if (dest.kind === "pageNumber")
+      return Math.max(0, Math.min(this.getPageCount() - 1, dest.value - 1));
     return null;
   }
   destroy() {
-    this.renditions.forEach((rendition) => rendition?.destroy?.());
-    this.renditions.clear();
-    this.renditionTargets.clear();
+    this.renderVersion += 1;
+    this.renderLock = Promise.resolve();
+    this.pendingHrefDestination = null;
+    this.destinationSequence = [];
+    this.destinationCursor = -1;
+    this.lastDestinationNavTime = 0;
+    this.lastDestinationPageIndex = null;
+    this.lastDestinationHref = null;
+    this.disposeReader();
     this.pageSizes.clear();
     if (this.book?.destroy) this.book.destroy();
     this.book = null;
     this.spineItems = [];
+    this.coverUrl = null;
   }
   applyRenditionTheme(rendition) {
     if (!rendition) return;
-    const fontSize = `${Math.round(this.zoom * 100)}%`;
+    const fontSize = "100%";
     if (rendition.themes?.fontSize) {
       rendition.themes.fontSize(fontSize);
     } else if (rendition.themes?.override) {
@@ -216,13 +583,457 @@ var EPUBEngine = class extends import_core.BaseDocumentEngine {
   }
   getSpineIndexByHref(href) {
     const normalized = this.normalizeHref(href);
+    const decoded = this.decodeHref(normalized);
     if (!normalized) return -1;
-    const index = this.spineItems.findIndex((item) => this.normalizeHref(item.href) === normalized);
-    return index;
+    const candidates = new Set([normalized, decoded].filter(Boolean));
+    const exactIndex = this.spineItems.findIndex((item) => {
+      const itemHref = this.normalizeHref(item.href);
+      const itemDecoded = this.decodeHref(itemHref);
+      return candidates.has(itemHref) || candidates.has(itemDecoded);
+    });
+    if (exactIndex >= 0) return exactIndex;
+    return this.spineItems.findIndex((item) => {
+      const itemHref = this.normalizeHref(item.href);
+      if (!itemHref) return false;
+      const itemDecoded = this.decodeHref(itemHref);
+      for (const candidate of candidates) {
+        if (itemHref.endsWith(candidate) || candidate.endsWith(itemHref) || itemDecoded.endsWith(candidate) || candidate.endsWith(itemDecoded)) {
+          return true;
+        }
+      }
+      return false;
+    });
   }
   normalizeHref(href) {
+    if (!href) return "";
     return href.split("#")[0];
   }
+  decodeHref(href) {
+    if (!href) return "";
+    try {
+      return decodeURIComponent(href);
+    } catch {
+      return href;
+    }
+  }
+  getSectionFromHref(href) {
+    const normalized = this.normalizeHref(href);
+    if (!normalized || !this.book?.spine?.get) return null;
+    const decoded = this.decodeHref(normalized);
+    const candidates = [normalized, decoded];
+    for (const candidate of candidates) {
+      if (!candidate) continue;
+      try {
+        const section = this.book.spine.get(candidate);
+        if (section) return section;
+      } catch {
+      }
+    }
+    return null;
+  }
+  getSpineItemForPage(pageIndex) {
+    const spineIndex = this.toSpineIndex(pageIndex);
+    if (spineIndex < 0 || spineIndex >= this.spineItems.length) return null;
+    return this.spineItems[spineIndex] ?? null;
+  }
+  getSpineIndexForSection(section) {
+    if (!section) return -1;
+    const sectionIdRef = typeof section?.idref === "string" ? section.idref.trim() : "";
+    if (sectionIdRef) {
+      const idrefIndex = this.spineItems.findIndex(
+        (item) => typeof item?.idref === "string" && item.idref.trim() === sectionIdRef
+      );
+      if (idrefIndex >= 0) return idrefIndex;
+    }
+    const sectionHref = typeof section?.href === "string" ? this.normalizeHref(section.href) : "";
+    if (sectionHref) {
+      const hrefIndex = this.getSpineIndexByHref(sectionHref);
+      if (hrefIndex >= 0) return hrefIndex;
+    }
+    if (typeof section?.index === "number" && section.index >= 0) {
+      const directItem = this.spineItems[section.index];
+      if (directItem) {
+        const directHref = this.normalizeHref(directItem?.href ?? "");
+        const directIdRef = typeof directItem?.idref === "string" ? directItem.idref.trim() : "";
+        const hasSameHref = Boolean(sectionHref && directHref === sectionHref);
+        const hasSameIdRef = Boolean(
+          sectionIdRef && directIdRef && directIdRef === sectionIdRef
+        );
+        if (hasSameHref || hasSameIdRef) return section.index;
+      }
+    }
+    return -1;
+  }
+  getPageIndexFromSection(section) {
+    const spineIndex = this.getSpineIndexForSection(section);
+    if (spineIndex < 0) return null;
+    return this.toPageIndexFromSpine(spineIndex);
+  }
+  isHrefMatchingSpineItem(href, spineItem) {
+    const normalizedCandidate = this.normalizeHref(href);
+    if (!normalizedCandidate) return false;
+    const decodedCandidate = this.decodeHref(normalizedCandidate);
+    const itemHref = this.normalizeHref(spineItem?.href ?? "");
+    if (!itemHref) return false;
+    const itemDecoded = this.decodeHref(itemHref);
+    for (const candidate of [normalizedCandidate, decodedCandidate]) {
+      if (!candidate) continue;
+      if (itemHref === candidate || itemDecoded === candidate || itemHref.endsWith(candidate) || candidate.endsWith(itemHref) || itemDecoded.endsWith(candidate) || candidate.endsWith(itemDecoded)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  uniqueDisplayTargets(targets) {
+    const deduped = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const target of targets) {
+      if (typeof target !== "string" && typeof target !== "number") continue;
+      const normalized = typeof target === "string" ? target.trim() : String(target).trim();
+      if (!normalized) continue;
+      const key = `${typeof target}:${normalized}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      deduped.push(target);
+    }
+    return deduped;
+  }
+  getDisplayTargetsForSpineItem(spineItem) {
+    const targets = [];
+    const seen = /* @__PURE__ */ new Set();
+    const pushTarget = (value) => {
+      if (typeof value !== "string" && typeof value !== "number") return;
+      const normalized = typeof value === "string" ? value.trim() : String(value).trim();
+      if (!normalized) return;
+      const key = `${typeof value}:${normalized}`;
+      if (seen.has(key)) return;
+      seen.add(key);
+      targets.push(value);
+    };
+    pushTarget(spineItem?.href);
+    pushTarget(this.decodeHref(spineItem?.href ?? ""));
+    pushTarget(spineItem?.idref);
+    pushTarget(spineItem?.cfiBase);
+    if (typeof spineItem?.index === "number") pushTarget(spineItem.index);
+    const sectionFromHref = this.getSectionFromHref(spineItem?.href ?? "");
+    if (sectionFromHref) {
+      pushTarget(sectionFromHref.href);
+      pushTarget(sectionFromHref.idref);
+      pushTarget(sectionFromHref.cfiBase);
+      if (typeof sectionFromHref.index === "number")
+        pushTarget(sectionFromHref.index);
+    }
+    return targets;
+  }
+  normalizeDestinationKey(href) {
+    if (!href) return "";
+    const trimmed = href.trim();
+    if (!trimmed) return "";
+    return this.decodeHref(trimmed).toLowerCase();
+  }
+  findDestinationIndexByHref(href) {
+    const candidate = this.normalizeDestinationKey(href);
+    if (!candidate || !this.destinationSequence.length) return -1;
+    const exact = this.destinationSequence.findIndex(
+      (entry) => this.normalizeDestinationKey(entry.href) === candidate
+    );
+    if (exact >= 0) return exact;
+    return this.destinationSequence.findIndex((entry) => {
+      const key = this.normalizeDestinationKey(entry.href);
+      return key === candidate || key.endsWith(candidate) || candidate.endsWith(key);
+    });
+  }
+  findNearestDestinationIndexByPage(pageIndex) {
+    if (!this.destinationSequence.length) return -1;
+    const candidates = this.destinationSequence.map((entry, idx) => ({ idx, pageIndex: entry.pageIndex })).filter((entry) => entry.pageIndex <= pageIndex);
+    if (candidates.length) return candidates[candidates.length - 1].idx;
+    const firstNext = this.destinationSequence.findIndex(
+      (entry) => entry.pageIndex >= pageIndex
+    );
+    return firstNext >= 0 ? firstNext : this.destinationSequence.length - 1;
+  }
+  async ensureDestinationSequence() {
+    if (this.destinationSequence.length) return;
+    if (!this.book?.loaded?.navigation) return;
+    const nav = await this.book.loaded.navigation;
+    const toc = nav?.toc ?? [];
+    if (!Array.isArray(toc) || !toc.length) return;
+    const hrefs = [];
+    const walk = (items) => {
+      for (const item of items) {
+        const href = typeof item?.href === "string" ? item.href.trim() : "";
+        if (href) hrefs.push(href);
+        if (Array.isArray(item?.subitems) && item.subitems.length) {
+          walk(item.subitems);
+        }
+      }
+    };
+    walk(toc);
+    if (!hrefs.length) return;
+    const deduped = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const href of hrefs) {
+      const key = this.normalizeDestinationKey(href);
+      if (!key || seen.has(key)) continue;
+      seen.add(key);
+      deduped.push(href);
+    }
+    const sequence = [];
+    for (const href of deduped) {
+      const pageIndex = await this.resolvePageIndexFromHref(href);
+      if (pageIndex == null) continue;
+      sequence.push({ href, pageIndex });
+    }
+    this.destinationSequence = sequence;
+    if (this.destinationCursor < 0 && sequence.length) {
+      this.destinationCursor = this.findNearestDestinationIndexByPage(
+        this.currentPage - 1
+      );
+    }
+  }
+  updateDestinationCursor(href, pageIndex) {
+    if (!this.destinationSequence.length) {
+      void this.ensureDestinationSequence().then(() => {
+        if (!this.destinationSequence.length) return;
+        this.updateDestinationCursor(href, pageIndex);
+      });
+      return;
+    }
+    const byHref = this.findDestinationIndexByHref(href);
+    if (byHref >= 0) {
+      this.destinationCursor = byHref;
+      return;
+    }
+    if (typeof pageIndex === "number" && pageIndex >= 0) {
+      const byPage = this.findNearestDestinationIndexByPage(pageIndex);
+      if (byPage >= 0) this.destinationCursor = byPage;
+    }
+  }
+  getSectionFromTarget(target) {
+    if (!this.book?.spine?.get) return null;
+    try {
+      const section = this.book.spine.get(target);
+      if (section) return section;
+    } catch {
+    }
+    if (typeof target === "string") {
+      return this.getSectionFromHref(target);
+    }
+    return null;
+  }
+  getPageIndexFromRenditionLocation(rendition) {
+    const location = rendition?.currentLocation?.();
+    if (!location) return null;
+    const starts = Array.isArray(location) ? location.map((entry) => entry?.start).filter(Boolean) : [location?.start];
+    for (const start of starts) {
+      if (!start) continue;
+      const href = typeof start?.href === "string" ? this.normalizeHref(start.href) : "";
+      if (href) {
+        const hrefIndex = this.getSpineIndexByHref(href);
+        if (hrefIndex >= 0) return this.toPageIndexFromSpine(hrefIndex);
+      }
+      if (typeof start?.index === "number" && start.index >= 0) {
+        const section = this.getSectionFromTarget(start.index);
+        const sectionPageIndex = this.getPageIndexFromSection(section);
+        if (sectionPageIndex != null) return sectionPageIndex;
+      }
+    }
+    return null;
+  }
+  isNoSectionError(error) {
+    if (!error || typeof error !== "object") return false;
+    const message = "message" in error && typeof error.message === "string" ? error.message : "";
+    return message.includes("No Section Found");
+  }
+  isTransientDisplayError(error) {
+    if (!error || typeof error !== "object") return false;
+    const message = "message" in error && typeof error.message === "string" ? error.message : "";
+    if (!message) return false;
+    const normalized = message.toLowerCase();
+    return normalized.includes("cannot read properties of undefined") || normalized.includes("cannot read properties of null") || normalized.includes("reading 'package'") || normalized.includes('reading "package"');
+  }
+  async displayWithFallback(rendition, targets, isCancelled) {
+    for (const target of targets) {
+      if (isCancelled()) return null;
+      try {
+        await rendition.display(target);
+        if (isCancelled()) return null;
+        const section = this.getSectionFromTarget(target);
+        return typeof section?.index === "number" ? section.index : null;
+      } catch (error) {
+        if (this.isNoSectionError(error) || this.isTransientDisplayError(error)) {
+          continue;
+        }
+        throw error;
+      }
+    }
+    return void 0;
+  }
+  async displayDestinationWithRetry(rendition, href) {
+    const targets = this.uniqueDisplayTargets([href, this.decodeHref(href)]);
+    if (!targets.length) return false;
+    const hasAnchor = href.includes("#");
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      try {
+        const firstPass = await this.displayWithFallback(
+          rendition,
+          targets,
+          () => false
+        );
+        if (firstPass === void 0) {
+          this.debugLog("displayDestinationWithRetry:first-pass-miss", {
+            href,
+            attempt
+          });
+          continue;
+        }
+        if (!hasAnchor) return true;
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        const secondPass = await this.displayWithFallback(
+          rendition,
+          targets,
+          () => false
+        );
+        if (secondPass !== void 0) return true;
+        this.debugLog("displayDestinationWithRetry:second-pass-miss", {
+          href,
+          attempt
+        });
+      } catch {
+        this.debugLog("displayDestinationWithRetry:error", { href, attempt });
+      }
+      await new Promise((resolve) => setTimeout(resolve, 40 * (attempt + 1)));
+    }
+    return false;
+  }
+  isDebugEnabled() {
+    try {
+      const globalFlag = Boolean(globalThis?.__PAPYRUS_EPUB_DEBUG__);
+      if (globalFlag) return true;
+      const localStorageRef = globalThis?.localStorage;
+      if (!localStorageRef) return false;
+      const persisted = localStorageRef.getItem("papyrus:epubDebug");
+      return persisted === "1" || persisted === "true";
+    } catch {
+      return false;
+    }
+  }
+  debugLog(message, payload) {
+    if (!this.isDebugEnabled()) return;
+    if (payload === void 0) {
+      console.log("[EPUBEngine]", message);
+      return;
+    }
+    console.log("[EPUBEngine]", message, payload);
+  }
+  async syncSectionHeight(rendition, element, pageIndex, width, seedHeight, targetSectionIndex, skipResize = false) {
+    if (_EPUBEngine.USE_INTERNAL_IFRAME_SCROLL) {
+      const fallbackHeight = Math.max(360, Math.ceil(seedHeight));
+      element.style.height = `${fallbackHeight}px`;
+      this.pageSizes.set(pageIndex, { width, height: fallbackHeight });
+      if (!skipResize && typeof rendition?.resize === "function" && rendition.manager?.resize) {
+        try {
+          rendition.resize(width, fallbackHeight);
+        } catch {
+        }
+      }
+      return;
+    }
+    const measureElementHeight = (elementToMeasure) => {
+      const measuredElement = elementToMeasure;
+      if (!measuredElement) return 0;
+      const rectHeight = typeof measuredElement.getBoundingClientRect === "function" ? measuredElement.getBoundingClientRect().height : 0;
+      return Math.max(
+        measuredElement.scrollHeight ?? 0,
+        measuredElement.offsetHeight ?? 0,
+        measuredElement.clientHeight ?? 0,
+        Number.isFinite(rectHeight) ? rectHeight : 0
+      );
+    };
+    const measureDocumentHeight = (doc) => {
+      if (!doc) return 0;
+      return Math.max(
+        measureElementHeight(doc.documentElement),
+        measureElementHeight(doc.body)
+      );
+    };
+    const measureContentHeight = (strictTarget) => {
+      let measured = 0;
+      const contents = typeof rendition?.getContents === "function" ? rendition.getContents() : [];
+      if (Array.isArray(contents)) {
+        for (const content of contents) {
+          if (strictTarget && targetSectionIndex !== null && typeof content?.sectionIndex === "number" && content.sectionIndex !== targetSectionIndex) {
+            continue;
+          }
+          const doc = content?.document;
+          if (!doc) continue;
+          measured = Math.max(measured, measureDocumentHeight(doc));
+        }
+      }
+      if (measured > 0) return measured;
+      const frameSelector = strictTarget && targetSectionIndex !== null ? `.epub-view[ref="${targetSectionIndex}"] iframe` : "iframe";
+      const frame = element.querySelector(
+        frameSelector
+      );
+      const fallbackFrame = frame ?? (strictTarget && targetSectionIndex !== null ? element.querySelector("iframe") : null);
+      const selectedFrame = fallbackFrame ?? frame;
+      const frameDoc = selectedFrame?.contentDocument;
+      if (!frameDoc) return 0;
+      return measureDocumentHeight(frameDoc);
+    };
+    let contentHeight = measureContentHeight(true);
+    if (contentHeight <= 0 && targetSectionIndex !== null) {
+      contentHeight = measureContentHeight(false);
+    }
+    if (contentHeight <= 0) {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      contentHeight = measureContentHeight(true);
+      if (contentHeight <= 0 && targetSectionIndex !== null) {
+        contentHeight = measureContentHeight(false);
+      }
+    }
+    const measuredTarget = contentHeight > 0 ? Math.ceil(contentHeight + _EPUBEngine.HEIGHT_PADDING) : Math.ceil(seedHeight);
+    const minA4Height = this.getA4MinHeight(width);
+    const unclampedTarget = Math.max(minA4Height, measuredTarget);
+    const targetHeight = Math.max(
+      minA4Height,
+      Math.min(_EPUBEngine.MAX_SECTION_HEIGHT, unclampedTarget)
+    );
+    if (targetHeight !== unclampedTarget) {
+      this.debugLog("syncSectionHeight:clamped", {
+        pageIndex,
+        measuredTarget,
+        max: _EPUBEngine.MAX_SECTION_HEIGHT
+      });
+    }
+    if (targetHeight <= 0) return;
+    element.style.height = `${targetHeight}px`;
+    this.pageSizes.set(pageIndex, { width, height: targetHeight });
+    if (!skipResize && typeof rendition?.resize === "function" && rendition.manager?.resize) {
+      try {
+        rendition.resize(width, targetHeight);
+      } catch {
+      }
+    }
+  }
+  async resolvePageIndexFromHref(href) {
+    const normalizedHref = href.trim();
+    if (!normalizedHref) return null;
+    const section = this.getSectionFromHref(normalizedHref);
+    const sectionPageIndex = this.getPageIndexFromSection(section);
+    if (sectionPageIndex != null) return sectionPageIndex;
+    const spineIndex = this.getSpineIndexByHref(
+      this.normalizeHref(normalizedHref)
+    );
+    return spineIndex >= 0 ? this.toPageIndexFromSpine(spineIndex) : null;
+  }
+  extractHrefDestination(dest) {
+    if (typeof dest === "string") return dest;
+    if (dest?.kind === "href" && typeof dest.value === "string") {
+      return dest.value;
+    }
+    return null;
+  }
   isUriSource(source) {
     return typeof source === "object" && source !== null && "uri" in source;
   }
@@ -270,7 +1081,9 @@ var EPUBEngine = class extends import_core.BaseDocumentEngine {
   decodeBase64(value) {
     const clean = value.replace(/\s/g, "");
     if (typeof atob !== "function") {
-      throw new Error("[EPUBEngine] atob n\xE3o est\xE1 dispon\xEDvel para decodificar base64.");
+      throw new Error(
+        "[EPUBEngine] atob n\xE3o est\xE1 dispon\xEDvel para decodificar base64."
+      );
     }
     const binary = atob(clean);
     const len = binary.length;
@@ -289,6 +1102,372 @@ var EPUBEngine = class extends import_core.BaseDocumentEngine {
     if (value.length < 16) return false;
     return /^[A-Za-z0-9+/=]+$/.test(value);
   }
+  createRendition(element, width, height) {
+    const rendition = this.book.renderTo(element, {
+      width,
+      height,
+      flow: "scrolled-doc",
+      spread: "none",
+      method: "write",
+      overflow: _EPUBEngine.USE_INTERNAL_IFRAME_SCROLL ? "auto" : "hidden"
+    });
+    this.registerContentHook(rendition);
+    return rendition;
+  }
+  disposeReader() {
+    const rendition = this.readerRendition;
+    if (!rendition) return;
+    try {
+      rendition?.manager?.destroy?.();
+    } catch {
+    }
+    this.readerRendition = null;
+    this.readerTarget = null;
+    this.heightSyncVersion += 1;
+  }
+  registerContentHook(rendition) {
+    if (!rendition?.hooks?.content?.register) return;
+    rendition.hooks.content.register((contents) => {
+      try {
+        const setImportantStyle = (node, property, value) => {
+          if (!node) return;
+          node.style.setProperty(property, value, "important");
+        };
+        const useInternalScroll = _EPUBEngine.USE_INTERNAL_IFRAME_SCROLL;
+        const managerContainer = rendition?.manager?.container;
+        const viewsContainer = rendition?.manager?.views?.container;
+        if (managerContainer) {
+          managerContainer.classList.add("papyrus-epub-scroll-host");
+          managerContainer.style.overflow = useInternalScroll ? "auto" : "hidden";
+          managerContainer.style.overflowY = useInternalScroll ? "auto" : "hidden";
+          managerContainer.style.overflowX = "hidden";
+          managerContainer.style.height = "100%";
+          managerContainer.style.maxHeight = "100%";
+          managerContainer.style.scrollbarWidth = useInternalScroll ? "thin" : "none";
+          managerContainer.style.setProperty(
+            "-webkit-overflow-scrolling",
+            "touch"
+          );
+          managerContainer.style.setProperty("overscroll-behavior", "contain");
+        }
+        if (viewsContainer) {
+          viewsContainer.style.overflow = useInternalScroll ? "visible" : "hidden";
+          viewsContainer.style.overflowY = useInternalScroll ? "visible" : "hidden";
+          viewsContainer.style.overflowX = "hidden";
+          viewsContainer.style.minHeight = "100%";
+          viewsContainer.style.scrollbarWidth = useInternalScroll ? "auto" : "none";
+        }
+        const frame = contents?.window?.frameElement;
+        const mobileProbe = managerContainer ?? frame ?? contents?.document?.body;
+        const mobileWidthHint = Math.max(
+          managerContainer?.clientWidth ?? 0,
+          frame?.clientWidth ?? 0,
+          mobileProbe?.clientWidth ?? 0
+        );
+        const isMobileInternalScroll = Boolean(
+          useInternalScroll && mobileProbe && this.isMobileViewport(mobileProbe, mobileWidthHint)
+        );
+        const contentOverflow = useInternalScroll ? "hidden" : "visible";
+        const doc = contents?.document;
+        const root = doc?.documentElement;
+        const body = doc?.body;
+        contents?.overflow?.(contentOverflow);
+        contents?.overflowX?.("hidden");
+        contents?.overflowY?.(contentOverflow);
+        contents?.css?.("overflow", contentOverflow, true);
+        contents?.css?.("overflow-y", contentOverflow, true);
+        contents?.css?.("overflow-x", "hidden", true);
+        contents?.css?.("height", "auto", true);
+        contents?.css?.("max-height", "none", true);
+        contents?.css?.("min-height", "100%", true);
+        if (root) {
+          setImportantStyle(root, "overflow", contentOverflow);
+          setImportantStyle(root, "overflow-y", contentOverflow);
+          setImportantStyle(root, "overflow-x", "hidden");
+          setImportantStyle(root, "height", "auto");
+          setImportantStyle(root, "min-height", "100%");
+          setImportantStyle(root, "max-height", "none");
+          setImportantStyle(root, "scrollbar-width", "none");
+          setImportantStyle(root, "overscroll-behavior", "none");
+        }
+        if (body) {
+          setImportantStyle(body, "overflow", contentOverflow);
+          setImportantStyle(body, "overflow-y", contentOverflow);
+          setImportantStyle(body, "overflow-x", "hidden");
+          setImportantStyle(body, "height", "auto");
+          setImportantStyle(body, "min-height", "100%");
+          setImportantStyle(body, "max-height", "none");
+          setImportantStyle(body, "scrollbar-width", "none");
+          setImportantStyle(body, "overscroll-behavior", "none");
+          if (isMobileInternalScroll) {
+            setImportantStyle(body, "margin", "0");
+            setImportantStyle(body, "padding", "0");
+          }
+        }
+        if (useInternalScroll && managerContainer && doc && root) {
+          const proxyMarker = "data-papyrus-scroll-proxy";
+          if (!root.hasAttribute(proxyMarker)) {
+            root.setAttribute(proxyMarker, "1");
+            const scrollHost = managerContainer;
+            const onWheel = (event) => {
+              if (event.defaultPrevented) return;
+              if (event.ctrlKey || event.metaKey) return;
+              const deltaY = Number(event.deltaY) || 0;
+              const deltaX = Number(event.deltaX) || 0;
+              if (!deltaY && !deltaX) return;
+              const previousTop = scrollHost.scrollTop;
+              const previousLeft = scrollHost.scrollLeft;
+              scrollHost.scrollTop += deltaY;
+              scrollHost.scrollLeft += deltaX;
+              const moved = scrollHost.scrollTop !== previousTop || scrollHost.scrollLeft !== previousLeft;
+              if (moved && event.cancelable) event.preventDefault();
+            };
+            let lastTouchY = null;
+            let lastTouchX = null;
+            const onTouchStart = (event) => {
+              if (event.touches.length !== 1) return;
+              lastTouchY = event.touches[0].clientY;
+              lastTouchX = event.touches[0].clientX;
+            };
+            const onTouchMove = (event) => {
+              if (event.touches.length !== 1) return;
+              const touch = event.touches[0];
+              if (lastTouchY == null || lastTouchX == null) {
+                lastTouchY = touch.clientY;
+                lastTouchX = touch.clientX;
+                return;
+              }
+              const deltaY = lastTouchY - touch.clientY;
+              const deltaX = lastTouchX - touch.clientX;
+              const previousTop = scrollHost.scrollTop;
+              const previousLeft = scrollHost.scrollLeft;
+              if (deltaY || deltaX) {
+                scrollHost.scrollTop += deltaY;
+                scrollHost.scrollLeft += deltaX;
+              }
+              const moved = scrollHost.scrollTop !== previousTop || scrollHost.scrollLeft !== previousLeft;
+              if (moved && event.cancelable) event.preventDefault();
+              lastTouchY = touch.clientY;
+              lastTouchX = touch.clientX;
+            };
+            const onTouchEnd = () => {
+              lastTouchY = null;
+              lastTouchX = null;
+            };
+            doc.addEventListener("wheel", onWheel, { passive: false });
+            doc.addEventListener("touchstart", onTouchStart, {
+              passive: true
+            });
+            doc.addEventListener("touchmove", onTouchMove, {
+              passive: false
+            });
+            doc.addEventListener("touchend", onTouchEnd, { passive: true });
+            doc.addEventListener("touchcancel", onTouchEnd, {
+              passive: true
+            });
+          }
+        }
+        if (isMobileInternalScroll && doc?.body) {
+          const singleImage = this.getSingleImageForMobileLayout(doc);
+          if (singleImage) {
+            doc.body.style.display = "flex";
+            doc.body.style.justifyContent = "center";
+            doc.body.style.alignItems = "flex-start";
+            singleImage.style.width = "100%";
+            singleImage.style.maxWidth = "100%";
+            singleImage.style.height = "auto";
+            singleImage.style.maxHeight = "100%";
+            singleImage.style.display = "block";
+            singleImage.style.objectFit = "contain";
+          }
+        }
+        if (frame) {
+          if (useInternalScroll) {
+            frame.setAttribute("scrolling", "no");
+            setImportantStyle(frame, "overflow", "hidden");
+            setImportantStyle(frame, "overflow-y", "hidden");
+            setImportantStyle(frame, "overflow-x", "hidden");
+            setImportantStyle(frame, "height", "auto");
+            setImportantStyle(frame, "min-height", "100%");
+            setImportantStyle(frame, "max-height", "none");
+            setImportantStyle(frame, "width", "100%");
+            setImportantStyle(frame, "max-width", "100%");
+            setImportantStyle(frame, "display", "block");
+            setImportantStyle(frame, "border", "0");
+          } else {
+            frame.setAttribute("scrolling", "no");
+            setImportantStyle(frame, "overflow", "hidden");
+            setImportantStyle(frame, "height", "auto");
+          }
+        }
+      } catch {
+      }
+    });
+  }
+  scheduleHeightSync(syncVersion, rendition, element, pageIndex, width, fallbackHeight, targetSectionIndex, skipResize = false) {
+    const run = () => {
+      if (syncVersion !== this.heightSyncVersion) return;
+      if (this.readerRendition !== rendition) return;
+      if (this.readerTarget !== element) return;
+      void this.syncSectionHeight(
+        rendition,
+        element,
+        pageIndex,
+        width,
+        fallbackHeight,
+        targetSectionIndex,
+        skipResize
+      );
+    };
+    setTimeout(run, 80);
+    setTimeout(run, 260);
+    setTimeout(run, 620);
+    setTimeout(run, 1200);
+  }
+  getViewportHeightHint(element) {
+    const viewerRoot = element.closest(".papyrus-viewer");
+    const hostParent = element.parentElement;
+    const measured = Math.max(
+      viewerRoot?.clientHeight ?? 0,
+      hostParent?.clientHeight ?? 0,
+      element.clientHeight ?? 0
+    );
+    if (measured <= 0) return null;
+    const viewportWidth = Math.max(
+      viewerRoot?.clientWidth ?? 0,
+      globalThis?.visualViewport?.width ?? 0,
+      globalThis?.innerWidth ?? 0
+    );
+    const isMobileViewport = viewportWidth > 0 && viewportWidth <= _EPUBEngine.MOBILE_VIEWPORT_MAX_WIDTH_PX;
+    if (!isMobileViewport) return null;
+    let topbarOffset = 0;
+    const shell = viewerRoot?.parentElement?.parentElement;
+    if (shell) {
+      const shellHeight = shell.getBoundingClientRect().height;
+      const topbar = Array.from(shell.children).find(
+        (child) => child.classList?.contains("papyrus-topbar")
+      );
+      const topbarHeight = topbar?.getBoundingClientRect().height ?? 0;
+      const viewerLikelyIncludesTopbar = topbarHeight > 0 && shellHeight > 0 && measured >= shellHeight - 2;
+      if (viewerLikelyIncludesTopbar) {
+        topbarOffset = Math.ceil(topbarHeight);
+      }
+    }
+    const adjusted = measured - topbarOffset - _EPUBEngine.INTERNAL_VIEWPORT_PADDING_PX;
+    return Math.max(280, Math.floor(adjusted));
+  }
+  getLinearSpineItems(items) {
+    const linearItems = items.filter((item) => item?.linear !== "no");
+    if (!linearItems.length) return items;
+    const deduped = [];
+    for (const item of linearItems) {
+      const prev = deduped[deduped.length - 1];
+      const prevHref = this.normalizeHref(prev?.href ?? "");
+      const currentHref = this.normalizeHref(item?.href ?? "");
+      if (prevHref && currentHref && prevHref === currentHref) continue;
+      deduped.push(item);
+    }
+    return deduped.length ? deduped : linearItems;
+  }
+  hasCoverPage() {
+    return Boolean(this.coverUrl);
+  }
+  isCoverPage(pageIndex) {
+    return this.hasCoverPage() && pageIndex === 0;
+  }
+  toSpineIndex(pageIndex) {
+    return pageIndex - (this.hasCoverPage() ? 1 : 0);
+  }
+  toPageIndexFromSpine(spineIndex) {
+    return spineIndex + (this.hasCoverPage() ? 1 : 0);
+  }
+  getA4MinHeight(width) {
+    if (!Number.isFinite(width) || width <= 0) return 900;
+    return Math.max(480, Math.ceil(width * _EPUBEngine.A4_RATIO));
+  }
+  renderCoverPage(element, width, height, pageIndex) {
+    this.disposeReader();
+    element.innerHTML = "";
+    element.style.width = `${width}px`;
+    element.style.height = `${height}px`;
+    const isMobileViewport = this.isMobileViewport(element, width);
+    const isLandscapeViewport = width > height;
+    const wrapper = document.createElement("div");
+    wrapper.style.width = "100%";
+    wrapper.style.minHeight = `${height}px`;
+    wrapper.style.display = "flex";
+    wrapper.style.alignItems = "center";
+    wrapper.style.justifyContent = "center";
+    wrapper.style.background = "#fff";
+    wrapper.style.padding = isMobileViewport ? "0" : "16px";
+    wrapper.style.boxSizing = "border-box";
+    if (isMobileViewport) {
+      wrapper.style.overflow = "hidden";
+    }
+    const img = document.createElement("img");
+    img.src = this.coverUrl ?? "";
+    img.alt = "Capa";
+    img.style.maxWidth = "100%";
+    img.style.maxHeight = "100%";
+    img.style.width = isMobileViewport ? "100%" : "auto";
+    img.style.height = isMobileViewport ? "100%" : "auto";
+    img.style.display = "block";
+    img.style.objectFit = isMobileViewport && !isLandscapeViewport ? "cover" : "contain";
+    img.style.boxShadow = isMobileViewport ? "none" : "0 16px 32px rgba(0,0,0,0.15)";
+    img.style.borderRadius = isMobileViewport ? "0" : "8px";
+    img.onload = () => {
+      if (isMobileViewport) {
+        const targetHeight2 = Math.max(280, Math.floor(height));
+        wrapper.style.minHeight = `${targetHeight2}px`;
+        element.style.height = `${targetHeight2}px`;
+        this.pageSizes.set(pageIndex, { width, height: targetHeight2 });
+        return;
+      }
+      const naturalWidth = img.naturalWidth || width;
+      const naturalHeight = img.naturalHeight || height;
+      if (naturalWidth <= 0 || naturalHeight <= 0) return;
+      const displayedWidth = Math.min(naturalWidth, Math.max(1, width - 32));
+      const scaledHeight = Math.round(
+        naturalHeight / naturalWidth * displayedWidth
+      );
+      const targetHeight = Math.max(height, scaledHeight + 32);
+      wrapper.style.minHeight = `${targetHeight}px`;
+      element.style.height = `${targetHeight}px`;
+      this.pageSizes.set(pageIndex, { width, height: targetHeight });
+    };
+    wrapper.appendChild(img);
+    element.appendChild(wrapper);
+    this.pageSizes.set(pageIndex, { width, height });
+  }
+  isMobileViewport(element, widthHint) {
+    const viewerRoot = element.closest(".papyrus-viewer");
+    const viewportWidth = Math.max(
+      widthHint,
+      viewerRoot?.clientWidth ?? 0,
+      globalThis?.visualViewport?.width ?? 0,
+      globalThis?.innerWidth ?? 0
+    );
+    const viewportHeight = Math.max(
+      viewerRoot?.clientHeight ?? 0,
+      globalThis?.visualViewport?.height ?? 0,
+      globalThis?.innerHeight ?? 0
+    );
+    const isShortLandscape = viewportHeight > 0 && viewportHeight <= _EPUBEngine.MOBILE_SHORT_VIEWPORT_MAX_HEIGHT_PX && viewportWidth > viewportHeight;
+    return Boolean(
+      viewportWidth > 0 && (viewportWidth <= _EPUBEngine.MOBILE_VIEWPORT_MAX_WIDTH_PX || isShortLandscape)
+    );
+  }
+  getSingleImageForMobileLayout(doc) {
+    const body = doc.body;
+    if (!body) return null;
+    const images = Array.from(
+      body.querySelectorAll("img")
+    );
+    if (images.length !== 1) return null;
+    const textLength = (body.textContent ?? "").replace(/\s+/g, "").length;
+    if (textLength > 48) return null;
+    return images[0] ?? null;
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {