pdfnova 1.0.0

package/dist/chunk-2OWW5BYD.mjs

@@ -0,0 +1,1847 @@
+import { RENDER_FLAG } from './chunk-G7575D5X.mjs';
+
+// src/core/WasmLoader.ts
+var PDFIUM_WASM_CDN = "https://cdn.jsdelivr.net/npm/@embedpdf/pdfium@2/dist/pdfium.wasm";
+var IDB_NAME = "pdfnova-cache";
+var IDB_STORE = "wasm";
+var IDB_KEY = "pdfium-binary";
+var wasmInstance = null;
+var initPromise = null;
+var forceMock = false;
+var WasmLoader = class _WasmLoader {
+  static async load(options) {
+    if (wasmInstance) return wasmInstance;
+    if (initPromise) return initPromise;
+    initPromise = _WasmLoader._doLoad(options);
+    wasmInstance = await initPromise;
+    return wasmInstance;
+  }
+  static isLoaded() {
+    return wasmInstance !== null;
+  }
+  static getInstance() {
+    return wasmInstance;
+  }
+  static reset() {
+    if (wasmInstance) {
+      try {
+        wasmInstance._FPDF_DestroyLibrary();
+      } catch {
+      }
+    }
+    wasmInstance = null;
+    initPromise = null;
+  }
+  /** Force mock mode (for unit tests in non-browser environments). */
+  static enableMock() {
+    forceMock = true;
+  }
+  static disableMock() {
+    forceMock = false;
+  }
+  /** Clear the cached WASM binary from IndexedDB. */
+  static async clearCache() {
+    try {
+      const db = await _WasmLoader._openIDB();
+      const tx = db.transaction(IDB_STORE, "readwrite");
+      tx.objectStore(IDB_STORE).delete(IDB_KEY);
+      await new Promise((res, rej) => {
+        tx.oncomplete = () => res();
+        tx.onerror = () => rej(tx.error);
+      });
+      db.close();
+    } catch {
+    }
+  }
+  static async _doLoad(options) {
+    if (forceMock || !_WasmLoader._canLoadWasm()) {
+      const { createMockModule } = await import('./WasmMock-2I3GVRQF.mjs');
+      return createMockModule();
+    }
+    return _WasmLoader._loadRealPdfium(options);
+  }
+  static _canLoadWasm() {
+    return typeof globalThis.WebAssembly !== "undefined" && typeof globalThis.fetch === "function" && typeof globalThis.document !== "undefined";
+  }
+  static async _loadRealPdfium(options) {
+    const wasmUrl = options?.wasmUrl ?? PDFIUM_WASM_CDN;
+    const { init } = await import('@embedpdf/pdfium');
+    let wasmBinary = await _WasmLoader._loadFromCache();
+    if (!wasmBinary) {
+      const response = await fetch(wasmUrl);
+      if (!response.ok) throw new Error(`Failed to fetch PDFium WASM: ${response.status}`);
+      wasmBinary = await response.arrayBuffer();
+      _WasmLoader._saveToCache(wasmBinary).catch(() => {
+      });
+    }
+    const wrapped = await init({ wasmBinary });
+    wrapped.PDFiumExt_Init();
+    return _WasmLoader._adaptModule(wrapped);
+  }
+  // ─── IndexedDB WASM cache ────────────────────────────────────
+  static async _openIDB() {
+    return new Promise((resolve, reject) => {
+      const req = indexedDB.open(IDB_NAME, 1);
+      req.onupgradeneeded = () => {
+        req.result.createObjectStore(IDB_STORE);
+      };
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => reject(req.error);
+    });
+  }
+  static async _loadFromCache() {
+    try {
+      if (typeof indexedDB === "undefined") return null;
+      const db = await _WasmLoader._openIDB();
+      const tx = db.transaction(IDB_STORE, "readonly");
+      const req = tx.objectStore(IDB_STORE).get(IDB_KEY);
+      const result = await new Promise((res, rej) => {
+        req.onsuccess = () => res(req.result ?? null);
+        req.onerror = () => rej(req.error);
+      });
+      db.close();
+      return result;
+    } catch {
+      return null;
+    }
+  }
+  static async _saveToCache(binary) {
+    try {
+      if (typeof indexedDB === "undefined") return;
+      const db = await _WasmLoader._openIDB();
+      const tx = db.transaction(IDB_STORE, "readwrite");
+      tx.objectStore(IDB_STORE).put(binary, IDB_KEY);
+      await new Promise((res, rej) => {
+        tx.oncomplete = () => res();
+        tx.onerror = () => rej(tx.error);
+      });
+      db.close();
+    } catch {
+    }
+  }
+  /**
+   * Adapts an @embedpdf/pdfium WrappedPdfiumModule to our WasmModule interface.
+   * Uses cwrap with all-number signatures for raw C-level pointer-based access,
+   * matching the interface that WasmBridge and all downstream code expects.
+   */
+  static _adaptModule(wrapped) {
+    const raw = wrapped.pdfium;
+    const cw = (name, ret, args) => raw.cwrap(name, ret, args);
+    const module = {
+      get HEAPU8() {
+        return raw.HEAPU8;
+      },
+      get HEAPU32() {
+        return raw.HEAPU32;
+      },
+      get HEAP32() {
+        return raw.HEAP32;
+      },
+      get HEAPF32() {
+        return raw.HEAPF32;
+      },
+      get HEAPF64() {
+        return raw.HEAPF64;
+      },
+      _malloc: raw.wasmExports.malloc,
+      _free: raw.wasmExports.free,
+      // PDFiumExt_Init already called — this is a no-op
+      _FPDF_InitLibraryWithConfig: () => {
+      },
+      _FPDF_DestroyLibrary: cw("FPDF_DestroyLibrary", null, []),
+      _FPDF_LoadMemDocument: cw("FPDF_LoadMemDocument", "number", ["number", "number", "number"]),
+      _FPDF_CloseDocument: cw("FPDF_CloseDocument", null, ["number"]),
+      _FPDF_GetLastError: cw("FPDF_GetLastError", "number", []),
+      _FPDF_GetPageCount: cw("FPDF_GetPageCount", "number", ["number"]),
+      _FPDF_LoadPage: cw("FPDF_LoadPage", "number", ["number", "number"]),
+      _FPDF_ClosePage: cw("FPDF_ClosePage", null, ["number"]),
+      _FPDF_GetPageWidthF: cw("FPDF_GetPageWidthF", "number", ["number"]),
+      _FPDF_GetPageHeightF: cw("FPDF_GetPageHeightF", "number", ["number"]),
+      _FPDFBitmap_Create: cw("FPDFBitmap_Create", "number", ["number", "number", "number"]),
+      _FPDFBitmap_FillRect: cw("FPDFBitmap_FillRect", null, ["number", "number", "number", "number", "number", "number"]),
+      _FPDFBitmap_GetBuffer: cw("FPDFBitmap_GetBuffer", "number", ["number"]),
+      _FPDFBitmap_GetStride: cw("FPDFBitmap_GetStride", "number", ["number"]),
+      _FPDFBitmap_Destroy: cw("FPDFBitmap_Destroy", null, ["number"]),
+      _FPDF_RenderPageBitmap: cw("FPDF_RenderPageBitmap", null, ["number", "number", "number", "number", "number", "number", "number", "number"]),
+      _FPDFText_LoadPage: cw("FPDFText_LoadPage", "number", ["number"]),
+      _FPDFText_ClosePage: cw("FPDFText_ClosePage", null, ["number"]),
+      _FPDFText_CountChars: cw("FPDFText_CountChars", "number", ["number"]),
+      _FPDFText_GetUnicode: cw("FPDFText_GetUnicode", "number", ["number", "number"]),
+      _FPDFText_GetFontSize: cw("FPDFText_GetFontSize", "number", ["number", "number"]),
+      _FPDFText_GetCharBox: cw("FPDFText_GetCharBox", "number", ["number", "number", "number", "number", "number", "number"]),
+      _FPDFText_GetText: cw("FPDFText_GetText", "number", ["number", "number", "number", "number"]),
+      _FPDFText_FindStart: cw("FPDFText_FindStart", "number", ["number", "number", "number", "number"]),
+      _FPDFText_FindNext: cw("FPDFText_FindNext", "number", ["number"]),
+      _FPDFText_FindClose: cw("FPDFText_FindClose", null, ["number"]),
+      _FPDFText_GetSchResultIndex: cw("FPDFText_GetSchResultIndex", "number", ["number"]),
+      _FPDFText_GetSchCount: cw("FPDFText_GetSchCount", "number", ["number"]),
+      _FPDFText_CountRects: cw("FPDFText_CountRects", "number", ["number", "number", "number"]),
+      _FPDFText_GetRect: cw("FPDFText_GetRect", "number", ["number", "number", "number", "number", "number", "number"]),
+      _FPDF_GetMetaText: cw("FPDF_GetMetaText", "number", ["number", "number", "number", "number"]),
+      _FPDFBookmark_GetFirstChild: cw("FPDFBookmark_GetFirstChild", "number", ["number", "number"]),
+      _FPDFBookmark_GetNextSibling: cw("FPDFBookmark_GetNextSibling", "number", ["number", "number"]),
+      _FPDFBookmark_GetTitle: cw("FPDFBookmark_GetTitle", "number", ["number", "number", "number"]),
+      _FPDFBookmark_GetAction: cw("FPDFBookmark_GetAction", "number", ["number"]),
+      _FPDFBookmark_GetDest: cw("FPDFBookmark_GetDest", "number", ["number", "number"]),
+      _FPDFDest_GetDestPageIndex: cw("FPDFDest_GetDestPageIndex", "number", ["number", "number"]),
+      _FPDFLink_LoadWebLinks: cw("FPDFLink_LoadWebLinks", "number", ["number"]),
+      _FPDFLink_CountWebLinks: cw("FPDFLink_CountWebLinks", "number", ["number"]),
+      _FPDFLink_GetURL: cw("FPDFLink_GetURL", "number", ["number", "number", "number", "number"]),
+      _FPDFLink_CountRects: cw("FPDFLink_CountRects", "number", ["number", "number"]),
+      _FPDFLink_GetRect: cw("FPDFLink_GetRect", "number", ["number", "number", "number", "number", "number", "number", "number"]),
+      _FPDFLink_CloseWebLinks: cw("FPDFLink_CloseWebLinks", null, ["number"]),
+      // Full-tier: annotations
+      _FPDFPage_GetAnnotCount: cw("FPDFPage_GetAnnotCount", "number", ["number"]),
+      _FPDFPage_GetAnnot: cw("FPDFPage_GetAnnot", "number", ["number", "number"]),
+      _FPDFPage_CreateAnnot: cw("FPDFPage_CreateAnnot", "number", ["number", "number"]),
+      _FPDFPage_RemoveAnnot: cw("FPDFPage_RemoveAnnot", "number", ["number", "number"]),
+      _FPDFAnnot_GetSubtype: cw("FPDFAnnot_GetSubtype", "number", ["number"]),
+      _FPDFAnnot_GetRect: cw("FPDFAnnot_GetRect", "number", ["number", "number"]),
+      _FPDFAnnot_SetRect: cw("FPDFAnnot_SetRect", "number", ["number", "number"]),
+      _FPDFAnnot_GetColor: cw("FPDFAnnot_GetColor", "number", ["number", "number", "number", "number", "number", "number"]),
+      _FPDFAnnot_SetColor: cw("FPDFAnnot_SetColor", "number", ["number", "number", "number", "number", "number", "number"]),
+      _FPDFAnnot_GetStringValue: cw("FPDFAnnot_GetStringValue", "number", ["number", "number", "number", "number"]),
+      _FPDFAnnot_SetStringValue: cw("FPDFAnnot_SetStringValue", "number", ["number", "number", "number"]),
+      _FPDFAnnot_AppendAttachmentPoints: cw("FPDFAnnot_AppendAttachmentPoints", "number", ["number", "number"]),
+      _FPDFAnnot_CountAttachmentPoints: cw("FPDFAnnot_CountAttachmentPoints", "number", ["number"]),
+      _FPDFAnnot_GetAttachmentPoints: cw("FPDFAnnot_GetAttachmentPoints", "number", ["number", "number", "number"]),
+      _FPDFPage_CloseAnnot: cw("FPDFPage_CloseAnnot", null, ["number"]),
+      // Full-tier: forms
+      _FPDFDOC_InitFormFillEnvironment: cw("FPDFDOC_InitFormFillEnvironment", "number", ["number", "number"]),
+      _FPDFDOC_ExitFormFillEnvironment: cw("FPDFDOC_ExitFormFillEnvironment", null, ["number"]),
+      _FPDF_GetFormType: cw("FPDF_GetFormType", "number", ["number"]),
+      _FPDFPage_HasFormFieldAtPoint: cw("FPDFPage_HasFormFieldAtPoint", "number", ["number", "number", "number", "number"]),
+      _FORM_OnMouseMove: cw("FORM_OnMouseMove", "number", ["number", "number", "number", "number", "number"]),
+      _FPDFAnnot_GetFormFieldType: cw("FPDFAnnot_GetFormFieldType", "number", ["number", "number"]),
+      _FPDFAnnot_GetFormFieldName: cw("FPDFAnnot_GetFormFieldName", "number", ["number", "number", "number", "number"]),
+      _FPDFAnnot_GetFormFieldValue: cw("FPDFAnnot_GetFormFieldValue", "number", ["number", "number", "number", "number"]),
+      _FPDFAnnot_SetFormFieldValue: cw("FPDFAnnot_SetFormFieldValue", null, ["number", "number", "number"]),
+      _FPDFAnnot_GetFormFieldFlags: cw("FPDFAnnot_GetFormFieldFlags", "number", ["number", "number"]),
+      _FPDFAnnot_IsChecked: cw("FPDFAnnot_IsChecked", "number", ["number", "number"]),
+      _FPDFPage_Flatten: cw("FPDFPage_Flatten", "number", ["number", "number"]),
+      _FPDF_SaveAsCopy: cw("FPDF_SaveAsCopy", "number", ["number", "number", "number"]),
+      _FPDF_SaveWithVersion: cw("FPDF_SaveWithVersion", "number", ["number", "number", "number", "number"]),
+      // Full-tier: signatures (note: real PDFium uses FPDFSignatureObj, our interface uses FPDFSignObj)
+      _FPDF_GetSignatureCount: cw("FPDF_GetSignatureCount", "number", ["number"]),
+      _FPDF_GetSignatureObject: cw("FPDF_GetSignatureObject", "number", ["number", "number"]),
+      _FPDFSignObj_GetContents: cw("FPDFSignatureObj_GetContents", "number", ["number", "number", "number"]),
+      _FPDFSignObj_GetByteRange: cw("FPDFSignatureObj_GetByteRange", "number", ["number", "number", "number"]),
+      _FPDFSignObj_GetSubFilter: cw("FPDFSignatureObj_GetSubFilter", "number", ["number", "number", "number"]),
+      _FPDFSignObj_GetReason: cw("FPDFSignatureObj_GetReason", "number", ["number", "number", "number"]),
+      _FPDFSignObj_GetTime: cw("FPDFSignatureObj_GetTime", "number", ["number", "number", "number"]),
+      _FPDFSignObj_GetDocMDPPermission: cw("FPDFSignatureObj_GetDocMDPPermission", "number", ["number"]),
+      // Emscripten utilities
+      UTF8ToString: raw.UTF8ToString.bind(raw),
+      UTF16ToString: raw.UTF16ToString.bind(raw),
+      stringToUTF8: raw.stringToUTF8.bind(raw),
+      stringToUTF16: raw.stringToUTF16.bind(raw),
+      lengthBytesUTF8: (str) => new TextEncoder().encode(str).length,
+      lengthBytesUTF16: (str) => str.length * 2
+    };
+    return module;
+  }
+};
+
+// src/text/TextExtractor.ts
+var TextExtractor = class {
+  wasm;
+  bridge;
+  constructor(wasm, bridge) {
+    this.wasm = wasm;
+    this.bridge = bridge;
+  }
+  extractText(textPagePtr) {
+    const charCount = this.wasm._FPDFText_CountChars(textPagePtr);
+    if (charCount <= 0) return "";
+    const bufSize = (charCount + 1) * 2;
+    const buf = this.wasm._malloc(bufSize);
+    this.wasm._FPDFText_GetText(textPagePtr, 0, charCount, buf);
+    const text = this.bridge.readUTF16String(buf);
+    this.wasm._free(buf);
+    return text;
+  }
+  extractCharBoxes(textPagePtr) {
+    const charCount = this.wasm._FPDFText_CountChars(textPagePtr);
+    if (charCount <= 0) return [];
+    const leftPtr = this.bridge.allocateF64();
+    const rightPtr = this.bridge.allocateF64();
+    const bottomPtr = this.bridge.allocateF64();
+    const topPtr = this.bridge.allocateF64();
+    const boxes = [];
+    try {
+      for (let i = 0; i < charCount; i++) {
+        const unicode = this.wasm._FPDFText_GetUnicode(textPagePtr, i);
+        if (unicode === 0) continue;
+        const result = this.wasm._FPDFText_GetCharBox(
+          textPagePtr,
+          i,
+          leftPtr,
+          rightPtr,
+          bottomPtr,
+          topPtr
+        );
+        if (result) {
+          boxes.push({
+            char: String.fromCodePoint(unicode),
+            charCode: unicode,
+            left: this.bridge.readF64(leftPtr),
+            right: this.bridge.readF64(rightPtr),
+            bottom: this.bridge.readF64(bottomPtr),
+            top: this.bridge.readF64(topPtr),
+            fontSize: this.wasm._FPDFText_GetFontSize(textPagePtr, i),
+            index: i
+          });
+        }
+      }
+    } finally {
+      this.bridge.freeAll(leftPtr, rightPtr, bottomPtr, topPtr);
+    }
+    return boxes;
+  }
+  /**
+   * Groups consecutive characters into text spans based on spatial proximity
+   * and font size. Spans represent logical "words" or "runs" of text.
+   */
+  extractSpans(textPagePtr) {
+    const boxes = this.extractCharBoxes(textPagePtr);
+    if (boxes.length === 0) return [];
+    const spans = [];
+    let currentSpan = null;
+    for (const box of boxes) {
+      const isWhitespace = /\s/.test(box.char);
+      if (!currentSpan || isWhitespace || !this._isContinuation(currentSpan, box)) {
+        if (currentSpan && currentSpan.text.trim()) {
+          spans.push(currentSpan);
+        }
+        if (isWhitespace) {
+          currentSpan = null;
+          continue;
+        }
+        currentSpan = {
+          text: box.char,
+          x: box.left,
+          y: box.bottom,
+          width: box.right - box.left,
+          height: box.top - box.bottom,
+          fontSize: box.fontSize,
+          charIndex: box.index,
+          charCount: 1
+        };
+      } else {
+        currentSpan.text += box.char;
+        currentSpan.width = box.right - currentSpan.x;
+        currentSpan.height = Math.max(currentSpan.height, box.top - box.bottom);
+        currentSpan.charCount++;
+      }
+    }
+    if (currentSpan && currentSpan.text.trim()) {
+      spans.push(currentSpan);
+    }
+    return spans;
+  }
+  _isContinuation(span, box) {
+    const sameBaseline = Math.abs(span.y - box.bottom) < span.fontSize * 0.5;
+    const sameFontSize = Math.abs(span.fontSize - box.fontSize) < 0.5;
+    const horizontalGap = box.left - (span.x + span.width);
+    const maxGap = span.fontSize * 0.5;
+    return sameBaseline && sameFontSize && horizontalGap < maxGap && horizontalGap > -span.fontSize * 0.3;
+  }
+};
+
+// src/text/TextLayerBuilder.ts
+var TextLayerBuilder = class {
+  wasm;
+  bridge;
+  constructor(wasm, bridge) {
+    this.wasm = wasm;
+    this.bridge = bridge;
+  }
+  /**
+   * Build a text layer DOM structure inside the given container.
+   * Spans are absolutely positioned to match the rendered PDF pixels.
+   *
+   * @param textPagePtr - PDFium text page handle
+   * @param container - DOM element to append text layer into
+   * @param pageWidth - PDF page width in points
+   * @param pageHeight - PDF page height in points
+   * @param scale - Rendering scale factor (default 1.0)
+   */
+  build(textPagePtr, container, pageWidth, pageHeight, scale = 1) {
+    const layer = document.createElement("div");
+    layer.className = "pdfnova-text-layer";
+    layer.style.cssText = `
+      position: absolute;
+      top: 0;
+      left: 0;
+      width: ${pageWidth * scale}px;
+      height: ${pageHeight * scale}px;
+      overflow: hidden;
+      opacity: 0.25;
+      line-height: 1;
+      pointer-events: all;
+    `;
+    const extractor = new TextExtractor(this.wasm, this.bridge);
+    const spans = extractor.extractSpans(textPagePtr);
+    for (const span of spans) {
+      const el = this._createSpanElement(span, pageHeight, scale);
+      layer.appendChild(el);
+    }
+    container.appendChild(layer);
+    return layer;
+  }
+  /**
+   * Build a text layer using character-level positioning for maximum accuracy.
+   * Slower but pixel-perfect — use when precise text selection is critical.
+   */
+  buildCharLevel(textPagePtr, container, pageWidth, pageHeight, scale = 1) {
+    const layer = document.createElement("div");
+    layer.className = "pdfnova-text-layer pdfnova-text-layer--char-level";
+    layer.style.cssText = `
+      position: absolute;
+      top: 0;
+      left: 0;
+      width: ${pageWidth * scale}px;
+      height: ${pageHeight * scale}px;
+      overflow: hidden;
+      opacity: 0.25;
+      line-height: 1;
+      pointer-events: all;
+    `;
+    const extractor = new TextExtractor(this.wasm, this.bridge);
+    const charBoxes = extractor.extractCharBoxes(textPagePtr);
+    const runs = this._groupIntoRuns(charBoxes);
+    for (const run of runs) {
+      const runEl = document.createElement("span");
+      runEl.style.cssText = `
+        position: absolute;
+        left: ${run[0].left * scale}px;
+        top: ${(pageHeight - run[0].top) * scale}px;
+        font-size: ${run[0].fontSize * scale}px;
+        font-family: sans-serif;
+        white-space: pre;
+        transform-origin: 0% 0%;
+      `;
+      let text = "";
+      for (const box of run) {
+        text += box.char;
+      }
+      runEl.textContent = text;
+      const firstBox = run[0];
+      const lastBox = run[run.length - 1];
+      const expectedWidth = (lastBox.right - firstBox.left) * scale;
+      if (expectedWidth > 0 && runEl.textContent.length > 0) {
+        runEl.dataset.expectedWidth = String(expectedWidth);
+      }
+      layer.appendChild(runEl);
+    }
+    container.appendChild(layer);
+    return layer;
+  }
+  _createSpanElement(span, pageHeight, scale) {
+    const el = document.createElement("span");
+    const domX = span.x * scale;
+    const domY = (pageHeight - span.y - span.height) * scale;
+    const fontSize = span.fontSize * scale;
+    el.textContent = span.text;
+    el.style.cssText = `
+      position: absolute;
+      left: ${domX}px;
+      top: ${domY}px;
+      font-size: ${fontSize}px;
+      font-family: sans-serif;
+      white-space: pre;
+      transform-origin: 0% 0%;
+    `;
+    el.dataset.charIndex = String(span.charIndex);
+    el.dataset.charCount = String(span.charCount);
+    return el;
+  }
+  _groupIntoRuns(boxes) {
+    if (boxes.length === 0) return [];
+    const runs = [];
+    let currentRun = [boxes[0]];
+    for (let i = 1; i < boxes.length; i++) {
+      const prev = boxes[i - 1];
+      const curr = boxes[i];
+      const sameLine = Math.abs(prev.bottom - curr.bottom) < prev.fontSize * 0.5;
+      const gap = curr.left - prev.right;
+      const tooFar = gap > prev.fontSize * 2;
+      if (sameLine && !tooFar) {
+        currentRun.push(curr);
+      } else {
+        if (currentRun.length > 0) runs.push(currentRun);
+        currentRun = [curr];
+      }
+    }
+    if (currentRun.length > 0) runs.push(currentRun);
+    return runs;
+  }
+};
+
+// src/text/SearchEngine.ts
+var SearchEngine = class {
+  wasm;
+  bridge;
+  constructor(wasm, bridge) {
+    this.wasm = wasm;
+    this.bridge = bridge;
+  }
+  /**
+   * Search across all pages of a document.
+   */
+  searchDocument(docPtr, pageCount, query, options) {
+    if (!query) return [];
+    const allResults = [];
+    let globalMatchIndex = 0;
+    for (let i = 0; i < pageCount; i++) {
+      const pagePtr = this.wasm._FPDF_LoadPage(docPtr, i);
+      if (pagePtr === 0) continue;
+      const textPagePtr = this.wasm._FPDFText_LoadPage(pagePtr);
+      if (textPagePtr === 0) {
+        this.wasm._FPDF_ClosePage(pagePtr);
+        continue;
+      }
+      try {
+        const pageResults = this.searchPage(textPagePtr, i, query, options);
+        for (const result of pageResults) {
+          result.matchIndex = globalMatchIndex++;
+          allResults.push(result);
+        }
+      } finally {
+        this.wasm._FPDFText_ClosePage(textPagePtr);
+        this.wasm._FPDF_ClosePage(pagePtr);
+      }
+    }
+    return allResults;
+  }
+  /**
+   * Search within a single page's text content.
+   */
+  searchPage(textPagePtr, pageIndex, query, options) {
+    if (!query) return [];
+    const results = [];
+    let flags = 0;
+    if (options?.caseSensitive) flags |= 1;
+    if (options?.wholeWord) flags |= 2;
+    const queryPtr = this.bridge.allocateUTF16String(query);
+    try {
+      const findHandle = this.wasm._FPDFText_FindStart(textPagePtr, queryPtr, flags, 0);
+      if (findHandle === 0) return results;
+      try {
+        while (this.wasm._FPDFText_FindNext(findHandle)) {
+          const charIndex = this.wasm._FPDFText_GetSchResultIndex(findHandle);
+          const count = this.wasm._FPDFText_GetSchCount(findHandle);
+          if (charIndex >= 0 && count > 0) {
+            results.push({
+              pageIndex,
+              matchIndex: results.length,
+              charIndex,
+              charCount: count,
+              rects: this._getMatchRects(textPagePtr, charIndex, count),
+              text: this._getMatchText(textPagePtr, charIndex, count)
+            });
+          }
+        }
+      } finally {
+        this.wasm._FPDFText_FindClose(findHandle);
+      }
+    } finally {
+      this.bridge.free(queryPtr);
+    }
+    return results;
+  }
+  _getMatchRects(textPagePtr, charIndex, charCount) {
+    const numRects = this.wasm._FPDFText_CountRects(textPagePtr, charIndex, charCount);
+    if (numRects <= 0) return [];
+    const rects = [];
+    const leftPtr = this.bridge.allocateF64();
+    const topPtr = this.bridge.allocateF64();
+    const rightPtr = this.bridge.allocateF64();
+    const bottomPtr = this.bridge.allocateF64();
+    try {
+      for (let i = 0; i < numRects; i++) {
+        this.wasm._FPDFText_GetRect(textPagePtr, i, leftPtr, topPtr, rightPtr, bottomPtr);
+        rects.push({
+          left: this.bridge.readF64(leftPtr),
+          top: this.bridge.readF64(topPtr),
+          right: this.bridge.readF64(rightPtr),
+          bottom: this.bridge.readF64(bottomPtr)
+        });
+      }
+    } finally {
+      this.bridge.freeAll(leftPtr, topPtr, rightPtr, bottomPtr);
+    }
+    return rects;
+  }
+  _getMatchText(textPagePtr, charIndex, charCount) {
+    const bufSize = (charCount + 1) * 2;
+    const buf = this.wasm._malloc(bufSize);
+    this.wasm._FPDFText_GetText(textPagePtr, charIndex, charCount, buf);
+    const text = this.bridge.readUTF16String(buf);
+    this.wasm._free(buf);
+    return text;
+  }
+};
+
+// src/navigation/LinkExtractor.ts
+var LinkExtractor = class {
+  wasm;
+  bridge;
+  constructor(wasm, bridge) {
+    this.wasm = wasm;
+    this.bridge = bridge;
+  }
+  extractLinks(textPagePtr, pageIndex) {
+    const linkPageHandle = this.wasm._FPDFLink_LoadWebLinks(textPagePtr);
+    if (linkPageHandle === 0) return [];
+    const links = [];
+    try {
+      const count = this.wasm._FPDFLink_CountWebLinks(linkPageHandle);
+      for (let i = 0; i < count; i++) {
+        const url = this.bridge.getLinkURL(linkPageHandle, i);
+        if (!url) continue;
+        const rects = this._getLinkRects(linkPageHandle, i);
+        links.push({ url, rects, pageIndex });
+      }
+    } finally {
+      this.wasm._FPDFLink_CloseWebLinks(linkPageHandle);
+    }
+    return links;
+  }
+  _getLinkRects(linkPageHandle, linkIndex) {
+    const rectCount = this.wasm._FPDFLink_CountRects(linkPageHandle, linkIndex);
+    if (rectCount <= 0) return [];
+    const rects = [];
+    const leftPtr = this.bridge.allocateF64();
+    const topPtr = this.bridge.allocateF64();
+    const rightPtr = this.bridge.allocateF64();
+    const bottomPtr = this.bridge.allocateF64();
+    try {
+      for (let i = 0; i < rectCount; i++) {
+        this.wasm._FPDFLink_GetRect(linkPageHandle, linkIndex, i, leftPtr, topPtr, rightPtr, bottomPtr);
+        rects.push({
+          left: this.bridge.readF64(leftPtr),
+          top: this.bridge.readF64(topPtr),
+          right: this.bridge.readF64(rightPtr),
+          bottom: this.bridge.readF64(bottomPtr)
+        });
+      }
+    } finally {
+      this.bridge.freeAll(leftPtr, topPtr, rightPtr, bottomPtr);
+    }
+    return rects;
+  }
+};
+
+// src/capabilities.ts
+var currentTier = "lite";
+function setTier(tier) {
+  currentTier = tier;
+}
+function getTier() {
+  return currentTier;
+}
+function isFullTier() {
+  return currentTier === "full";
+}
+function requireFull(feature) {
+  if (currentTier !== "full") {
+    throw new Error(
+      `${feature} requires the full build of pdfnova. Import from 'pdfnova' instead of 'pdfnova/lite'.`
+    );
+  }
+}
+
+// src/core/MemoryManager.ts
+var MemoryManager = class {
+  wasm;
+  allocations = [];
+  disposed = false;
+  constructor(wasm) {
+    this.wasm = wasm;
+  }
+  alloc(size, label) {
+    if (this.disposed) throw new Error("MemoryManager has been disposed");
+    const ptr = this.wasm._malloc(size);
+    if (ptr === 0) throw new Error(`WASM allocation failed: ${size} bytes`);
+    this.allocations.push({ ptr, size, label });
+    return ptr;
+  }
+  allocF64(label) {
+    return this.alloc(8, label);
+  }
+  allocI32(label) {
+    return this.alloc(4, label);
+  }
+  allocBytes(data, label) {
+    const ptr = this.alloc(data.byteLength, label);
+    this.wasm.HEAPU8.set(data, ptr);
+    return ptr;
+  }
+  allocString(str, label) {
+    const encoded = new TextEncoder().encode(str);
+    const ptr = this.alloc(encoded.length + 1, label);
+    this.wasm.HEAPU8.set(encoded, ptr);
+    this.wasm.HEAPU8[ptr + encoded.length] = 0;
+    return ptr;
+  }
+  allocUTF16(str, label) {
+    const byteLen = (str.length + 1) * 2;
+    const ptr = this.alloc(byteLen, label);
+    this.wasm.stringToUTF16(str, ptr, byteLen);
+    return ptr;
+  }
+  readF64(ptr) {
+    return this.wasm.HEAPF64[ptr >> 3];
+  }
+  readI32(ptr) {
+    return this.wasm.HEAP32[ptr >> 2];
+  }
+  free(ptr) {
+    const idx = this.allocations.findIndex((a) => a.ptr === ptr);
+    if (idx >= 0) {
+      this.allocations.splice(idx, 1);
+    }
+    this.wasm._free(ptr);
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    for (const { ptr } of this.allocations) {
+      try {
+        this.wasm._free(ptr);
+      } catch {
+      }
+    }
+    this.allocations.length = 0;
+  }
+  get allocationCount() {
+    return this.allocations.length;
+  }
+  get totalAllocated() {
+    return this.allocations.reduce((sum, a) => sum + a.size, 0);
+  }
+};
+
+// src/document/PDFPage.ts
+var PDFPage = class _PDFPage {
+  wasm;
+  bridge;
+  docPtr;
+  _pageIndex;
+  pagePtr = 0;
+  textPagePtr = 0;
+  _formHandle;
+  _closed = false;
+  mem;
+  constructor(wasm, bridge, docPtr, pageIndex, formHandle) {
+    this.wasm = wasm;
+    this.bridge = bridge;
+    this.docPtr = docPtr;
+    this._pageIndex = pageIndex;
+    this._formHandle = formHandle;
+    this.mem = new MemoryManager(wasm);
+    this._load();
+  }
+  _load() {
+    this.pagePtr = this.wasm._FPDF_LoadPage(this.docPtr, this._pageIndex);
+    if (this.pagePtr === 0) {
+      throw new Error(`Failed to load page ${this._pageIndex}`);
+    }
+  }
+  // ─── Properties ──────────────────────────────────────────────
+  get pageIndex() {
+    return this._pageIndex;
+  }
+  get formHandle() {
+    return this._formHandle;
+  }
+  get width() {
+    this._assertOpen();
+    return this.wasm._FPDF_GetPageWidthF(this.pagePtr);
+  }
+  get height() {
+    this._assertOpen();
+    return this.wasm._FPDF_GetPageHeightF(this.pagePtr);
+  }
+  // ─── Rendering ───────────────────────────────────────────────
+  async render(canvas, options) {
+    this._assertOpen();
+    const scale = options?.scale ?? 1;
+    const rotation = options?.rotation ?? 0;
+    const rotationIndex = [0, 90, 180, 270].indexOf(rotation);
+    if (rotationIndex < 0) throw new RangeError("Rotation must be 0, 90, 180, or 270");
+    const isRotated90or270 = rotation === 90 || rotation === 270;
+    const pdfW = this.width;
+    const pdfH = this.height;
+    const renderW = Math.ceil((isRotated90or270 ? pdfH : pdfW) * scale);
+    const renderH = Math.ceil((isRotated90or270 ? pdfW : pdfH) * scale);
+    canvas.width = renderW;
+    canvas.height = renderH;
+    const baseFlags = options?.flags ?? RENDER_FLAG.ANNOT | RENDER_FLAG.LCD_TEXT;
+    const flags = baseFlags | RENDER_FLAG.REVERSE_BYTE_ORDER;
+    const bitmapHandle = this.wasm._FPDFBitmap_Create(renderW, renderH, 0);
+    if (bitmapHandle === 0) throw new Error("Failed to create bitmap");
+    try {
+      const bgColor = _PDFPage._parseColor(options?.background ?? "#ffffff");
+      this.wasm._FPDFBitmap_FillRect(bitmapHandle, 0, 0, renderW, renderH, bgColor);
+      this.wasm._FPDF_RenderPageBitmap(
+        bitmapHandle,
+        this.pagePtr,
+        0,
+        0,
+        renderW,
+        renderH,
+        rotationIndex,
+        flags
+      );
+      const bufferPtr = this.wasm._FPDFBitmap_GetBuffer(bitmapHandle);
+      const stride = this.wasm._FPDFBitmap_GetStride(bitmapHandle);
+      const ctx = canvas.getContext("2d");
+      if (!ctx) throw new Error("Failed to get canvas 2D context");
+      const imageData = ctx.createImageData(renderW, renderH);
+      const dst = imageData.data;
+      const rowBytes = renderW * 4;
+      for (let y = 0; y < renderH; y++) {
+        const srcOffset = bufferPtr + y * stride;
+        const dstOffset = y * rowBytes;
+        dst.set(this.wasm.HEAPU8.subarray(srcOffset, srcOffset + rowBytes), dstOffset);
+        for (let x = 3; x < rowBytes; x += 4) {
+          dst[dstOffset + x] = 255;
+        }
+      }
+      ctx.putImageData(imageData, 0, 0);
+    } finally {
+      this.wasm._FPDFBitmap_Destroy(bitmapHandle);
+    }
+  }
+  async renderToImageData(options) {
+    this._assertOpen();
+    const scale = options?.scale ?? 1;
+    const rotation = options?.rotation ?? 0;
+    const rotationIndex = [0, 90, 180, 270].indexOf(rotation);
+    if (rotationIndex < 0) throw new RangeError("Rotation must be 0, 90, 180, or 270");
+    const isRotated = rotation === 90 || rotation === 270;
+    const renderW = Math.ceil((isRotated ? this.height : this.width) * scale);
+    const renderH = Math.ceil((isRotated ? this.width : this.height) * scale);
+    const baseFlags = options?.flags ?? RENDER_FLAG.ANNOT | RENDER_FLAG.LCD_TEXT;
+    const flags = baseFlags | RENDER_FLAG.REVERSE_BYTE_ORDER;
+    const bitmapHandle = this.wasm._FPDFBitmap_Create(renderW, renderH, 0);
+    if (bitmapHandle === 0) throw new Error("Failed to create bitmap");
+    try {
+      const bgColor = _PDFPage._parseColor(options?.background ?? "#ffffff");
+      this.wasm._FPDFBitmap_FillRect(bitmapHandle, 0, 0, renderW, renderH, bgColor);
+      this.wasm._FPDF_RenderPageBitmap(
+        bitmapHandle,
+        this.pagePtr,
+        0,
+        0,
+        renderW,
+        renderH,
+        rotationIndex,
+        flags
+      );
+      const bufferPtr = this.wasm._FPDFBitmap_GetBuffer(bitmapHandle);
+      const stride = this.wasm._FPDFBitmap_GetStride(bitmapHandle);
+      const data = new Uint8ClampedArray(renderW * renderH * 4);
+      const rowBytes = renderW * 4;
+      for (let y = 0; y < renderH; y++) {
+        const srcOffset = bufferPtr + y * stride;
+        const dstOffset = y * rowBytes;
+        data.set(this.wasm.HEAPU8.subarray(srcOffset, srcOffset + rowBytes), dstOffset);
+        for (let x = 3; x < rowBytes; x += 4) {
+          data[dstOffset + x] = 255;
+        }
+      }
+      return new ImageData(data, renderW, renderH);
+    } finally {
+      this.wasm._FPDFBitmap_Destroy(bitmapHandle);
+    }
+  }
+  // ─── Text ────────────────────────────────────────────────────
+  getText() {
+    this._assertOpen();
+    this._ensureTextPage();
+    const extractor = new TextExtractor(this.wasm, this.bridge);
+    return extractor.extractText(this.textPagePtr);
+  }
+  getTextSpans() {
+    this._assertOpen();
+    this._ensureTextPage();
+    const extractor = new TextExtractor(this.wasm, this.bridge);
+    return extractor.extractSpans(this.textPagePtr);
+  }
+  getCharBoxes() {
+    this._assertOpen();
+    this._ensureTextPage();
+    const extractor = new TextExtractor(this.wasm, this.bridge);
+    return extractor.extractCharBoxes(this.textPagePtr);
+  }
+  createTextLayer(container) {
+    this._assertOpen();
+    this._ensureTextPage();
+    const builder = new TextLayerBuilder(this.wasm, this.bridge);
+    return builder.build(this.textPagePtr, container, this.width, this.height);
+  }
+  // ─── Search ──────────────────────────────────────────────────
+  search(query, options) {
+    this._assertOpen();
+    this._ensureTextPage();
+    const engine = new SearchEngine(this.wasm, this.bridge);
+    return engine.searchPage(this.textPagePtr, this._pageIndex, query, options);
+  }
+  // ─── Links ───────────────────────────────────────────────────
+  getLinks() {
+    this._assertOpen();
+    this._ensureTextPage();
+    const extractor = new LinkExtractor(this.wasm, this.bridge);
+    return extractor.extractLinks(this.textPagePtr, this._pageIndex);
+  }
+  // ─── Annotations (full tier) ─────────────────────────────────
+  async getAnnotations() {
+    requireFull("Annotation reading");
+    this._assertOpen();
+    const { AnnotationReader } = await import('./AnnotationReader-ADHPZ3V5.mjs');
+    const reader = new AnnotationReader(this.wasm, this.bridge);
+    return reader.readAnnotations(this.pagePtr);
+  }
+  async addAnnotation(opts) {
+    requireFull("Annotation creation");
+    this._assertOpen();
+    const { AnnotationWriter } = await import('./AnnotationWriter-XWY5N6AZ.mjs');
+    const writer = new AnnotationWriter(this.wasm, this.bridge);
+    writer.addAnnotation(this.pagePtr, opts);
+  }
+  async removeAnnotation(index) {
+    requireFull("Annotation removal");
+    this._assertOpen();
+    const { AnnotationWriter } = await import('./AnnotationWriter-XWY5N6AZ.mjs');
+    const writer = new AnnotationWriter(this.wasm, this.bridge);
+    writer.removeAnnotation(this.pagePtr, index);
+  }
+  // ─── Cleanup ─────────────────────────────────────────────────
+  close() {
+    if (this._closed) return;
+    this._closed = true;
+    if (this.textPagePtr) {
+      this.wasm._FPDFText_ClosePage(this.textPagePtr);
+      this.textPagePtr = 0;
+    }
+    if (this.pagePtr) {
+      this.wasm._FPDF_ClosePage(this.pagePtr);
+      this.pagePtr = 0;
+    }
+    this.mem.dispose();
+  }
+  [Symbol.dispose]() {
+    this.close();
+  }
+  // ─── Internal ────────────────────────────────────────────────
+  _ensureTextPage() {
+    if (this.textPagePtr) return;
+    this.textPagePtr = this.wasm._FPDFText_LoadPage(this.pagePtr);
+    if (this.textPagePtr === 0) {
+      throw new Error(`Failed to load text page for page ${this._pageIndex}`);
+    }
+  }
+  _assertOpen() {
+    if (this._closed) throw new Error("Page has been closed");
+  }
+  static _parseColor(hex) {
+    const clean = hex.replace("#", "");
+    const r = parseInt(clean.slice(0, 2), 16);
+    const g = parseInt(clean.slice(2, 4), 16);
+    const b = parseInt(clean.slice(4, 6), 16);
+    const a = clean.length > 6 ? parseInt(clean.slice(6, 8), 16) : 255;
+    return (r << 24 | g << 16 | b << 8 | a) >>> 0;
+  }
+};
+
+// src/navigation/OutlineExtractor.ts
+var OutlineExtractor = class {
+  wasm;
+  bridge;
+  constructor(wasm, bridge) {
+    this.wasm = wasm;
+    this.bridge = bridge;
+  }
+  extract(docPtr) {
+    return this._walkBookmarks(docPtr, 0);
+  }
+  _walkBookmarks(docPtr, parentBookmark) {
+    const items = [];
+    let bookmark = this.wasm._FPDFBookmark_GetFirstChild(docPtr, parentBookmark);
+    while (bookmark !== 0) {
+      const title = this.bridge.getBookmarkTitle(bookmark);
+      let pageIndex = -1;
+      const dest = this.wasm._FPDFBookmark_GetDest(docPtr, bookmark);
+      if (dest !== 0) {
+        pageIndex = this.wasm._FPDFDest_GetDestPageIndex(docPtr, dest);
+      } else {
+        this.wasm._FPDFBookmark_GetAction(bookmark);
+      }
+      const children = this._walkBookmarks(docPtr, bookmark);
+      items.push({ title, pageIndex, children });
+      bookmark = this.wasm._FPDFBookmark_GetNextSibling(docPtr, bookmark);
+    }
+    return items;
+  }
+};
+
+// src/core/WasmBridge.ts
+var WasmBridge = class {
+  wasm;
+  constructor(wasm) {
+    this.wasm = wasm ?? WasmLoader.getInstance();
+  }
+  get module() {
+    return this.wasm;
+  }
+  allocateString(str) {
+    const len = this.wasm.lengthBytesUTF8(str) + 1;
+    const ptr = this.wasm._malloc(len);
+    this.wasm.stringToUTF8(str, ptr, len);
+    return ptr;
+  }
+  allocateUTF16String(str) {
+    const byteLen = (str.length + 1) * 2;
+    const ptr = this.wasm._malloc(byteLen);
+    this.wasm.stringToUTF16(str, ptr, byteLen);
+    return ptr;
+  }
+  readString(ptr) {
+    return this.wasm.UTF8ToString(ptr);
+  }
+  readUTF16String(ptr) {
+    return this.wasm.UTF16ToString(ptr);
+  }
+  copyToHeap(data) {
+    const ptr = this.wasm._malloc(data.byteLength);
+    this.wasm.HEAPU8.set(data, ptr);
+    return ptr;
+  }
+  copyFromHeap(ptr, size) {
+    return new Uint8Array(this.wasm.HEAPU8.buffer, ptr, size).slice();
+  }
+  allocateF64() {
+    return this.wasm._malloc(8);
+  }
+  readF64(ptr) {
+    return this.wasm.HEAPF64[ptr >> 3];
+  }
+  allocateI32() {
+    return this.wasm._malloc(4);
+  }
+  readI32(ptr) {
+    return this.wasm.HEAP32[ptr >> 2];
+  }
+  free(ptr) {
+    this.wasm._free(ptr);
+  }
+  freeAll(...ptrs) {
+    for (const ptr of ptrs) {
+      if (ptr) this.wasm._free(ptr);
+    }
+  }
+  getMetaText(docPtr, tag) {
+    const tagPtr = this.allocateString(tag);
+    const needed = this.wasm._FPDF_GetMetaText(docPtr, tagPtr, 0, 0);
+    if (needed <= 0) {
+      this.free(tagPtr);
+      return "";
+    }
+    const buf = this.wasm._malloc(needed);
+    this.wasm._FPDF_GetMetaText(docPtr, tagPtr, buf, needed);
+    const value = this.readUTF16String(buf);
+    this.freeAll(tagPtr, buf);
+    return value;
+  }
+  getBookmarkTitle(bookmark) {
+    const needed = this.wasm._FPDFBookmark_GetTitle(bookmark, 0, 0);
+    if (needed <= 0) return "";
+    const buf = this.wasm._malloc(needed);
+    this.wasm._FPDFBookmark_GetTitle(bookmark, buf, needed);
+    const title = this.readUTF16String(buf);
+    this.free(buf);
+    return title;
+  }
+  getLinkURL(linkPage, linkIndex) {
+    const needed = this.wasm._FPDFLink_GetURL(linkPage, linkIndex, 0, 0);
+    if (needed <= 0) return "";
+    const buf = this.wasm._malloc(needed * 2);
+    this.wasm._FPDFLink_GetURL(linkPage, linkIndex, buf, needed);
+    const url = this.readUTF16String(buf);
+    this.free(buf);
+    return url;
+  }
+  getAnnotStringValue(annot, key) {
+    if (!this.wasm._FPDFAnnot_GetStringValue) return "";
+    const keyPtr = this.allocateString(key);
+    const needed = this.wasm._FPDFAnnot_GetStringValue(annot, keyPtr, 0, 0);
+    if (needed <= 0) {
+      this.free(keyPtr);
+      return "";
+    }
+    const buf = this.wasm._malloc(needed);
+    this.wasm._FPDFAnnot_GetStringValue(annot, keyPtr, buf, needed);
+    const value = this.readUTF16String(buf);
+    this.freeAll(keyPtr, buf);
+    return value;
+  }
+  getFormFieldName(formHandle, annot) {
+    if (!this.wasm._FPDFAnnot_GetFormFieldName) return "";
+    const needed = this.wasm._FPDFAnnot_GetFormFieldName(formHandle, annot, 0, 0);
+    if (needed <= 0) return "";
+    const buf = this.wasm._malloc(needed);
+    this.wasm._FPDFAnnot_GetFormFieldName(formHandle, annot, buf, needed);
+    const name = this.readUTF16String(buf);
+    this.free(buf);
+    return name;
+  }
+  getFormFieldValue(formHandle, annot) {
+    if (!this.wasm._FPDFAnnot_GetFormFieldValue) return "";
+    const needed = this.wasm._FPDFAnnot_GetFormFieldValue(formHandle, annot, 0, 0);
+    if (needed <= 0) return "";
+    const buf = this.wasm._malloc(needed);
+    this.wasm._FPDFAnnot_GetFormFieldValue(formHandle, annot, buf, needed);
+    const value = this.readUTF16String(buf);
+    this.free(buf);
+    return value;
+  }
+  getSignatureStringField(sig, getter) {
+    const needed = getter(sig, 0, 0);
+    if (needed <= 0) return "";
+    const buf = this.wasm._malloc(needed);
+    getter(sig, buf, needed);
+    const value = this.readString(buf);
+    this.free(buf);
+    return value;
+  }
+  getSignatureBinaryField(sig, getter) {
+    const needed = getter(sig, 0, 0);
+    if (needed <= 0) return new Uint8Array(0);
+    const buf = this.wasm._malloc(needed);
+    getter(sig, buf, needed);
+    const data = this.copyFromHeap(buf, needed);
+    this.free(buf);
+    return data;
+  }
+};
+
+// src/document/PDFDocument.ts
+var FPDF_ERR_UNKNOWN = 1;
+var FPDF_ERR_FILE = 2;
+var FPDF_ERR_FORMAT = 3;
+var FPDF_ERR_PASSWORD = 4;
+var FPDF_ERR_SECURITY = 5;
+var FPDF_ERR_PAGE = 6;
+var ERROR_MESSAGES = {
+  [FPDF_ERR_UNKNOWN]: "Unknown error",
+  [FPDF_ERR_FILE]: "File not found or could not be opened",
+  [FPDF_ERR_FORMAT]: "File is not a valid PDF",
+  [FPDF_ERR_PASSWORD]: "Incorrect password",
+  [FPDF_ERR_SECURITY]: "Unsupported security scheme",
+  [FPDF_ERR_PAGE]: "Page not found or content error"
+};
+var PDFDocument = class _PDFDocument {
+  wasm;
+  bridge;
+  mem;
+  docPtr;
+  _pageCount;
+  _pages = /* @__PURE__ */ new Map();
+  _formHandle = null;
+  _closed = false;
+  _dataPtr = 0;
+  constructor(wasm, docPtr, dataPtr) {
+    this.wasm = wasm;
+    this.bridge = new WasmBridge(wasm);
+    this.mem = new MemoryManager(wasm);
+    this.docPtr = docPtr;
+    this._dataPtr = dataPtr;
+    this._pageCount = wasm._FPDF_GetPageCount(docPtr);
+  }
+  // ─── Static factory ──────────────────────────────────────────
+  static async open(source, options) {
+    const wasm = await WasmLoader.load({ wasmUrl: options?.wasmUrl });
+    const data = await _PDFDocument._resolveSource(source, options);
+    const bytes = new Uint8Array(data);
+    const dataPtr = wasm._malloc(bytes.byteLength);
+    wasm.HEAPU8.set(bytes, dataPtr);
+    let passwordPtr = 0;
+    if (options?.password) {
+      const pwBytes = new TextEncoder().encode(options.password);
+      passwordPtr = wasm._malloc(pwBytes.length + 1);
+      wasm.HEAPU8.set(pwBytes, passwordPtr);
+      wasm.HEAPU8[passwordPtr + pwBytes.length] = 0;
+    }
+    const docPtr = wasm._FPDF_LoadMemDocument(dataPtr, bytes.byteLength, passwordPtr);
+    if (passwordPtr) wasm._free(passwordPtr);
+    if (docPtr === 0) {
+      wasm._free(dataPtr);
+      const errCode = wasm._FPDF_GetLastError();
+      const msg = ERROR_MESSAGES[errCode] ?? `PDFium error code ${errCode}`;
+      const error = new Error(msg);
+      error.code = errCode;
+      throw error;
+    }
+    return new _PDFDocument(wasm, docPtr, dataPtr);
+  }
+  static async _resolveSource(source, options) {
+    if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+    if (source instanceof ArrayBuffer) return source;
+    if (source && typeof source === "object" && "byteLength" in source && typeof source.slice === "function")
+      return source;
+    if (typeof Blob !== "undefined" && source instanceof Blob) return source.arrayBuffer();
+    if (typeof source === "string") {
+      if (source.startsWith("data:")) {
+        const base64 = source.split(",")[1];
+        const binary = atob(base64);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+        return bytes.buffer;
+      }
+      const fetchOptions = {};
+      if (options?.headers) fetchOptions.headers = options.headers;
+      if (options?.credentials) fetchOptions.credentials = options.credentials;
+      const response = await fetch(source, fetchOptions);
+      if (!response.ok) throw new Error(`Failed to fetch PDF: ${response.status} ${response.statusText}`);
+      return response.arrayBuffer();
+    }
+    throw new Error("Unsupported source type");
+  }
+  // ─── Properties ──────────────────────────────────────────────
+  get pageCount() {
+    this._assertOpen();
+    return this._pageCount;
+  }
+  get metadata() {
+    this._assertOpen();
+    return {
+      title: this.bridge.getMetaText(this.docPtr, "Title"),
+      author: this.bridge.getMetaText(this.docPtr, "Author"),
+      subject: this.bridge.getMetaText(this.docPtr, "Subject"),
+      keywords: this.bridge.getMetaText(this.docPtr, "Keywords"),
+      creator: this.bridge.getMetaText(this.docPtr, "Creator"),
+      producer: this.bridge.getMetaText(this.docPtr, "Producer"),
+      creationDate: this.bridge.getMetaText(this.docPtr, "CreationDate"),
+      modDate: this.bridge.getMetaText(this.docPtr, "ModDate")
+    };
+  }
+  get permissions() {
+    this._assertOpen();
+    return {
+      print: true,
+      copy: true,
+      modify: true,
+      annotate: true,
+      fillForms: true,
+      extractForAccessibility: true,
+      assemble: true,
+      printHighQuality: true
+    };
+  }
+  get outline() {
+    this._assertOpen();
+    return new OutlineExtractor(this.wasm, this.bridge).extract(this.docPtr);
+  }
+  get isClosed() {
+    return this._closed;
+  }
+  // ─── Page access ─────────────────────────────────────────────
+  getPage(index) {
+    this._assertOpen();
+    if (index < 0 || index >= this._pageCount) {
+      throw new RangeError(`Page index ${index} out of range [0, ${this._pageCount - 1}]`);
+    }
+    let page = this._pages.get(index);
+    if (!page) {
+      page = new PDFPage(this.wasm, this.bridge, this.docPtr, index, this._formHandle);
+      this._pages.set(index, page);
+    }
+    return page;
+  }
+  // ─── Search ──────────────────────────────────────────────────
+  search(query, options) {
+    this._assertOpen();
+    const engine = new SearchEngine(this.wasm, this.bridge);
+    return engine.searchDocument(this.docPtr, this._pageCount, query, options);
+  }
+  // ─── Forms (full tier) ───────────────────────────────────────
+  initFormEnvironment() {
+    requireFull("Form filling");
+    this._assertOpen();
+    if (this._formHandle) return;
+    const formInfoPtr = this.mem.alloc(512, "formInfo");
+    this.wasm.HEAPU8.fill(0, formInfoPtr, formInfoPtr + 512);
+    this._formHandle = this.wasm._FPDFDOC_InitFormFillEnvironment(this.docPtr, formInfoPtr);
+  }
+  async getFormFields() {
+    requireFull("Form reading");
+    this._assertOpen();
+    if (!this._formHandle) this.initFormEnvironment();
+    const { FormReader } = await import('./FormReader-XEF3T5LD.mjs');
+    const reader = new FormReader(this.wasm, this.bridge);
+    return reader.readAllFields(this.docPtr, this._formHandle, this._pageCount);
+  }
+  async setFormField(name, value) {
+    requireFull("Form filling");
+    this._assertOpen();
+    if (!this._formHandle) this.initFormEnvironment();
+    const { FormFiller } = await import('./FormFiller-6DLWMRN5.mjs');
+    const filler = new FormFiller(this.wasm, this.bridge);
+    filler.setFieldValue(this.docPtr, this._formHandle, this._pageCount, name, value);
+  }
+  async flattenForms(usage = 0) {
+    requireFull("Form flattening");
+    this._assertOpen();
+    const { FormFlattener } = await import('./FormFlattener-YQRQ3QOY.mjs');
+    const flattener = new FormFlattener(this.wasm);
+    flattener.flattenAll(this.docPtr, this._pageCount, usage);
+  }
+  // ─── Signatures (full tier) ──────────────────────────────────
+  async getSignatures() {
+    requireFull("Signature reading");
+    this._assertOpen();
+    const { SignatureVerifier } = await import('./SignatureVerifier-2IR7UQGU.mjs');
+    const verifier = new SignatureVerifier(this.wasm, this.bridge);
+    return verifier.readSignatures(this.docPtr);
+  }
+  // ─── Save (full tier) ────────────────────────────────────────
+  async save() {
+    requireFull("Document saving");
+    this._assertOpen();
+    if (!this.wasm._FPDF_SaveAsCopy) {
+      throw new Error("Save not available in this build");
+    }
+    const pageCount = this._pageCount;
+    const estimatedSize = pageCount * 5e4;
+    const buf = new Uint8Array(estimatedSize);
+    return buf;
+  }
+  // ─── Cleanup ─────────────────────────────────────────────────
+  close() {
+    if (this._closed) return;
+    this._closed = true;
+    for (const page of this._pages.values()) {
+      page.close();
+    }
+    this._pages.clear();
+    if (this._formHandle && this.wasm._FPDFDOC_ExitFormFillEnvironment) {
+      this.wasm._FPDFDOC_ExitFormFillEnvironment(this._formHandle);
+      this._formHandle = null;
+    }
+    this.wasm._FPDF_CloseDocument(this.docPtr);
+    if (this._dataPtr) {
+      this.wasm._free(this._dataPtr);
+      this._dataPtr = 0;
+    }
+    this.mem.dispose();
+  }
+  [Symbol.dispose]() {
+    this.close();
+  }
+  // ─── Internal ────────────────────────────────────────────────
+  /** @internal */
+  get _docPtr() {
+    return this.docPtr;
+  }
+  /** @internal */
+  get _wasmModule() {
+    return this.wasm;
+  }
+  /** @internal */
+  get _wasmBridge() {
+    return this.bridge;
+  }
+  _assertOpen() {
+    if (this._closed) throw new Error("Document has been closed");
+  }
+};
+
+// src/document/PageRenderer.ts
+var PageRenderer = class {
+  /**
+   * Render a page to an HTMLCanvasElement or OffscreenCanvas.
+   */
+  static async renderToCanvas(page, canvas, options) {
+    return page.render(canvas, options);
+  }
+  /**
+   * Render a page to raw ImageData (no DOM required).
+   */
+  static async renderToImageData(page, options) {
+    return page.renderToImageData(options);
+  }
+  /**
+   * Generate a thumbnail at a specific maximum dimension.
+   */
+  static async renderThumbnail(page, canvas, maxDimension = 200) {
+    const aspect = page.width / page.height;
+    let scale;
+    if (aspect >= 1) {
+      scale = maxDimension / page.width;
+    } else {
+      scale = maxDimension / page.height;
+    }
+    return page.render(canvas, { scale });
+  }
+  /**
+   * Calculate the scale needed to fit a page within given dimensions.
+   */
+  static fitScale(page, containerWidth, containerHeight) {
+    const scaleX = containerWidth / page.width;
+    const scaleY = containerHeight / page.height;
+    return Math.min(scaleX, scaleY);
+  }
+  /**
+   * Calculate the scale needed to fit page width within container width.
+   */
+  static fitWidthScale(page, containerWidth) {
+    return containerWidth / page.width;
+  }
+};
+
+// src/document/VirtualRenderer.ts
+var VirtualRenderer = class {
+  doc = null;
+  container;
+  wrapper;
+  slots = [];
+  observer = null;
+  lru = [];
+  scale;
+  overscan;
+  cacheSize;
+  gap;
+  _destroyed = false;
+  constructor(options) {
+    this.container = options.container;
+    this.scale = options.scale ?? 1;
+    this.overscan = options.overscan ?? 2;
+    this.cacheSize = options.cacheSize ?? 10;
+    this.gap = options.gap ?? 8;
+    this.wrapper = document.createElement("div");
+    this.wrapper.className = "pdfnova-virtual-wrapper";
+    this.wrapper.style.cssText = "position: relative; width: 100%;";
+    this.container.appendChild(this.wrapper);
+  }
+  async setDocument(doc) {
+    this._cleanup();
+    this.doc = doc;
+    await this._buildSlots();
+    this._setupObserver();
+  }
+  setScale(scale) {
+    this.scale = scale;
+    if (this.doc) {
+      this._rebuildAllSlots();
+    }
+  }
+  getScale() {
+    return this.scale;
+  }
+  scrollToPage(pageIndex, behavior = "smooth") {
+    const slot = this.slots[pageIndex];
+    if (slot) {
+      slot.element.scrollIntoView({ behavior, block: "start" });
+    }
+  }
+  /**
+   * Returns the index of the page most visible in the viewport.
+   */
+  getCurrentPage() {
+    const containerRect = this.container.getBoundingClientRect();
+    const containerMid = containerRect.top + containerRect.height / 2;
+    let bestIndex = 0;
+    let bestDist = Infinity;
+    for (let i = 0; i < this.slots.length; i++) {
+      const rect = this.slots[i].element.getBoundingClientRect();
+      const mid = rect.top + rect.height / 2;
+      const dist = Math.abs(mid - containerMid);
+      if (dist < bestDist) {
+        bestDist = dist;
+        bestIndex = i;
+      }
+    }
+    return bestIndex;
+  }
+  destroy() {
+    if (this._destroyed) return;
+    this._destroyed = true;
+    this._cleanup();
+    this.wrapper.remove();
+  }
+  // ─── Private ──────────────────────────────────────────────────
+  async _buildSlots() {
+    if (!this.doc) return;
+    this.wrapper.innerHTML = "";
+    this.slots = [];
+    for (let i = 0; i < this.doc.pageCount; i++) {
+      const page = this.doc.getPage(i);
+      const w = page.width * this.scale;
+      const h = page.height * this.scale;
+      const el = document.createElement("div");
+      el.className = "pdfnova-page-slot";
+      el.dataset.pageIndex = String(i);
+      el.style.cssText = `
+        width: ${w}px;
+        height: ${h}px;
+        margin: 0 auto ${this.gap}px auto;
+        position: relative;
+        background: #f0f0f0;
+        overflow: hidden;
+      `;
+      const placeholder = document.createElement("div");
+      placeholder.className = "pdfnova-page-placeholder";
+      placeholder.style.cssText = `
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        width: 100%;
+        height: 100%;
+        color: #999;
+        font-size: 14px;
+      `;
+      placeholder.textContent = `Page ${i + 1}`;
+      el.appendChild(placeholder);
+      this.wrapper.appendChild(el);
+      this.slots.push({ element: el, canvas: null, rendered: false, pageIndex: i });
+    }
+  }
+  _setupObserver() {
+    if (this.observer) this.observer.disconnect();
+    const margin = `${this.overscan * 100}% 0px`;
+    this.observer = new IntersectionObserver(
+      (entries) => {
+        for (const entry of entries) {
+          const el = entry.target;
+          const pageIndex = parseInt(el.dataset.pageIndex ?? "-1", 10);
+          if (pageIndex < 0) continue;
+          if (entry.isIntersecting) {
+            this._renderSlot(pageIndex);
+          }
+        }
+      },
+      { root: this.container, rootMargin: margin, threshold: 0 }
+    );
+    for (const slot of this.slots) {
+      this.observer.observe(slot.element);
+    }
+  }
+  async _renderSlot(pageIndex) {
+    const slot = this.slots[pageIndex];
+    if (!slot || slot.rendered || !this.doc) return;
+    slot.rendered = true;
+    this._touchLRU(pageIndex);
+    const page = this.doc.getPage(pageIndex);
+    const canvas = document.createElement("canvas");
+    canvas.className = "pdfnova-page-canvas";
+    canvas.style.cssText = "position: absolute; top: 0; left: 0; width: 100%; height: 100%;";
+    await page.render(canvas, { scale: this.scale });
+    slot.element.innerHTML = "";
+    slot.element.appendChild(canvas);
+    slot.canvas = canvas;
+    this._evictLRU();
+  }
+  _touchLRU(pageIndex) {
+    const idx = this.lru.indexOf(pageIndex);
+    if (idx >= 0) this.lru.splice(idx, 1);
+    this.lru.push(pageIndex);
+  }
+  _evictLRU() {
+    while (this.lru.length > this.cacheSize) {
+      const evictIndex = this.lru.shift();
+      const slot = this.slots[evictIndex];
+      if (slot && slot.rendered) {
+        slot.rendered = false;
+        slot.canvas = null;
+        slot.element.innerHTML = "";
+        const placeholder = document.createElement("div");
+        placeholder.className = "pdfnova-page-placeholder";
+        placeholder.style.cssText = `
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          width: 100%;
+          height: 100%;
+          color: #999;
+          font-size: 14px;
+        `;
+        placeholder.textContent = `Page ${evictIndex + 1}`;
+        slot.element.appendChild(placeholder);
+      }
+    }
+  }
+  async _rebuildAllSlots() {
+    this.lru = [];
+    await this._buildSlots();
+    this._setupObserver();
+  }
+  _cleanup() {
+    if (this.observer) {
+      this.observer.disconnect();
+      this.observer = null;
+    }
+    this.slots = [];
+    this.lru = [];
+    this.wrapper.innerHTML = "";
+  }
+};
+
+// src/worker/PDFWorker.ts
+var PDFWorker = class {
+  worker = null;
+  nextId = 0;
+  pending = /* @__PURE__ */ new Map();
+  _ready = false;
+  async init(options) {
+    if (this.worker) return;
+    const workerCode = this._getWorkerScript();
+    const blob = new Blob([workerCode], { type: "application/javascript" });
+    const url = URL.createObjectURL(blob);
+    this.worker = new Worker(url, { type: "module" });
+    URL.revokeObjectURL(url);
+    this.worker.onmessage = (e) => {
+      const msg = e.data;
+      const handler = this.pending.get(msg.id);
+      if (!handler) return;
+      this.pending.delete(msg.id);
+      if (msg.type === "error") {
+        handler.reject(new Error(msg.message));
+      } else {
+        handler.resolve(msg.data);
+      }
+    };
+    this.worker.onerror = (e) => {
+      for (const [, handler] of this.pending) {
+        handler.reject(new Error(`Worker error: ${e.message}`));
+      }
+      this.pending.clear();
+    };
+    await this._send({
+      type: "init",
+      wasmUrl: options?.wasmUrl,
+      tier: options?.tier ?? "lite"
+    });
+    this._ready = true;
+  }
+  get ready() {
+    return this._ready;
+  }
+  async openDocument(data, password) {
+    return this._send({ type: "open", data, password }, [data]);
+  }
+  async renderPage(pageIndex, options) {
+    const result = await this._send({ type: "render", pageIndex, options });
+    return new ImageData(
+      new Uint8ClampedArray(result.data),
+      result.width,
+      result.height
+    );
+  }
+  async getText(pageIndex) {
+    return this._send({ type: "getText", pageIndex });
+  }
+  async getTextSpans(pageIndex) {
+    return this._send({ type: "getTextSpans", pageIndex });
+  }
+  async search(query, options) {
+    return this._send({ type: "search", query, options });
+  }
+  async closeDocument() {
+    await this._send({ type: "closeDoc" });
+  }
+  destroy() {
+    if (this.worker) {
+      this.worker.terminate();
+      this.worker = null;
+    }
+    this._ready = false;
+    for (const [, handler] of this.pending) {
+      handler.reject(new Error("Worker destroyed"));
+    }
+    this.pending.clear();
+  }
+  _send(request, transfer) {
+    if (!this.worker) throw new Error("Worker not initialized");
+    const id = this.nextId++;
+    const envelope = { id, request };
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      if (transfer?.length) {
+        this.worker.postMessage(envelope, transfer);
+      } else {
+        this.worker.postMessage(envelope);
+      }
+    });
+  }
+  _getWorkerScript() {
+    return `
+      let wasm = null;
+      let bridge = null;
+      let doc = null;
+
+      self.onmessage = async (e) => {
+        const { id, request } = e.data;
+
+        try {
+          let result;
+
+          switch (request.type) {
+            case 'init':
+              // In production, import pdfnova WASM loader here
+              result = { ready: true };
+              break;
+
+            case 'open':
+              result = { pageCount: 0 };
+              break;
+
+            case 'render':
+              result = { data: new ArrayBuffer(0), width: 0, height: 0 };
+              break;
+
+            case 'getText':
+              result = '';
+              break;
+
+            case 'getTextSpans':
+              result = [];
+              break;
+
+            case 'search':
+              result = [];
+              break;
+
+            case 'closeDoc':
+              doc = null;
+              result = null;
+              break;
+
+            case 'destroy':
+              doc = null;
+              wasm = null;
+              result = null;
+              break;
+          }
+
+          self.postMessage({ id, type: 'success', data: result });
+        } catch (err) {
+          self.postMessage({ id, type: 'error', message: err.message });
+        }
+      };
+    `;
+  }
+};
+
+// src/worker/WorkerPool.ts
+var WorkerPool = class {
+  workers = [];
+  queue = [];
+  activeCount = /* @__PURE__ */ new Map();
+  maxWorkers;
+  _initialized = false;
+  initOptions;
+  constructor(maxWorkers) {
+    this.maxWorkers = maxWorkers ?? (typeof navigator !== "undefined" ? navigator.hardwareConcurrency ?? 4 : 4);
+  }
+  async init(options) {
+    if (this._initialized) return;
+    this.initOptions = options;
+    const count = Math.min(this.maxWorkers, 4);
+    for (let i = 0; i < count; i++) {
+      const worker = new PDFWorker();
+      await worker.init(options);
+      this.workers.push(worker);
+      this.activeCount.set(worker, 0);
+    }
+    this._initialized = true;
+  }
+  get workerCount() {
+    return this.workers.length;
+  }
+  get pendingTasks() {
+    return this.queue.length;
+  }
+  async renderPage(pageIndex, options) {
+    return this._enqueue((worker) => worker.renderPage(pageIndex, options));
+  }
+  async getText(pageIndex) {
+    return this._enqueue((worker) => worker.getText(pageIndex));
+  }
+  async getTextSpans(pageIndex) {
+    return this._enqueue((worker) => worker.getTextSpans(pageIndex));
+  }
+  async search(query, options) {
+    return this._enqueue((worker) => worker.search(query, options));
+  }
+  /**
+   * Render multiple pages concurrently, returning results in order.
+   */
+  async renderPages(pageIndices, options) {
+    const promises = pageIndices.map((idx) => this.renderPage(idx, options));
+    return Promise.all(promises);
+  }
+  destroy() {
+    for (const worker of this.workers) {
+      worker.destroy();
+    }
+    this.workers = [];
+    this.activeCount.clear();
+    for (const task of this.queue) {
+      task.reject(new Error("Worker pool destroyed"));
+    }
+    this.queue = [];
+    this._initialized = false;
+  }
+  _enqueue(execute) {
+    return new Promise((resolve, reject) => {
+      this.queue.push({ resolve, reject, execute });
+      this._processQueue();
+    });
+  }
+  _processQueue() {
+    if (this.queue.length === 0) return;
+    const available = this._getLeastBusyWorker();
+    if (!available) {
+      this._maybeExpandPool();
+      return;
+    }
+    const task = this.queue.shift();
+    const count = this.activeCount.get(available) ?? 0;
+    this.activeCount.set(available, count + 1);
+    task.execute(available).then((result) => {
+      task.resolve(result);
+    }).catch((err) => {
+      task.reject(err);
+    }).finally(() => {
+      const c = this.activeCount.get(available) ?? 1;
+      this.activeCount.set(available, c - 1);
+      this._processQueue();
+    });
+  }
+  _getLeastBusyWorker() {
+    let best = null;
+    let bestCount = Infinity;
+    for (const [worker, count] of this.activeCount) {
+      if (count < bestCount) {
+        bestCount = count;
+        best = worker;
+      }
+    }
+    return best && bestCount < 2 ? best : null;
+  }
+  async _maybeExpandPool() {
+    if (this.workers.length >= this.maxWorkers) return;
+    const worker = new PDFWorker();
+    await worker.init(this.initOptions);
+    this.workers.push(worker);
+    this.activeCount.set(worker, 0);
+    this._processQueue();
+  }
+};
+
+export { LinkExtractor, OutlineExtractor, PDFDocument, PDFPage, PDFWorker, PageRenderer, SearchEngine, TextExtractor, TextLayerBuilder, VirtualRenderer, WasmLoader, WorkerPool, getTier, isFullTier, setTier };
+//# sourceMappingURL=chunk-2OWW5BYD.mjs.map
+//# sourceMappingURL=chunk-2OWW5BYD.mjs.map