@embedpdf/engines 2.6.0 → 2.6.2

package/dist/{direct-engine-CvfzIn2D.js → direct-engine-CmsmBgWP.js}

@@ -1,6 +1,6 @@
 import { init } from "@embedpdf/pdfium";
 import { Rotation, NoopLogger, PdfTaskHelper, PdfErrorCode, pdfDateToDate, isUuidV4, uuidV4, PdfAnnotationSubtype, PdfPageFlattenFlag, stripPdfUnwantedMarkers, PdfAnnotationIcon, PdfAnnotationBorderStyle, PdfAnnotationColorType, PdfAnnotationLineEnding, PdfStandardFont, PdfStampFit, PdfTrappedStatus, pdfColorToWebColor, webColorToPdfColor, pdfAlphaToWebOpacity, webOpacityToPdfAlpha, PdfAnnotationReplyType, dateToPdfDate, quadToRect, rectToQuad, PdfPageObjectType, flagsToNames, namesToFlags, PDF_FORM_FIELD_TYPE, AppearanceMode, Task, toIntRect, transformRect, buildUserToDeviceMatrix, PdfZoomMode, PdfActionType } from "@embedpdf/models";
-import { P as PdfEngine } from "./pdf-engine-aJNoNMbt.js";
+import { P as PdfEngine } from "./pdf-engine-C07l7iNd.js";
 import { b as browserImageDataToBlobConverter } from "./browser-BISJ9naB.js";
 function readString(wasmModule, readChars, parseChars, defaultLength = 100) {
   let buffer = wasmModule.wasmExports.malloc(defaultLength);
@@ -3732,7 +3732,8 @@ class PdfiumNative {
             height: g.size.height
           },
           charStart: i,
-          glyphs: []
+          glyphs: [],
+          fontSize: this.pdfiumModule.FPDFText_GetFontSize(textPagePtr, i)
         };
         bounds = {
           minX: g.origin.x,
@@ -3747,7 +3748,9 @@ class PdfiumNative {
         y: g.origin.y,
         width: g.size.width,
         height: g.size.height,
-        flags: g.isEmpty ? 2 : g.isSpace ? 1 : 0
+        flags: g.isEmpty ? 2 : g.isSpace ? 1 : 0,
+        ...g.tightOrigin && { tightX: g.tightOrigin.x, tightY: g.tightOrigin.y },
+        ...g.tightSize && { tightWidth: g.tightSize.width, tightHeight: g.tightSize.height }
       });
       if (g.isEmpty) {
         continue;
@@ -3765,6 +3768,184 @@ class PdfiumNative {
     }
     return runs;
   }
+  /**
+   * Rich text runs: groups consecutive characters sharing the same
+   * text object, font, size, and fill color into structured segments
+   * with full font metadata and bounding boxes in PDF page coordinates.
+   *
+   * @public
+   */
+  getPageTextRuns(doc, page) {
+    const label = "getPageTextRuns";
+    this.logger.perf(LOG_SOURCE, LOG_CATEGORY, label, "Begin", doc.id);
+    const ctx = this.cache.getContext(doc.id);
+    if (!ctx) {
+      this.logger.perf(LOG_SOURCE, LOG_CATEGORY, label, "End", doc.id);
+      return PdfTaskHelper.reject({
+        code: PdfErrorCode.DocNotOpen,
+        message: "document does not open"
+      });
+    }
+    const pageCtx = ctx.acquirePage(page.index);
+    const textPagePtr = pageCtx.getTextPage();
+    const charCount = this.pdfiumModule.FPDFText_CountChars(textPagePtr);
+    const runs = [];
+    let runStart = 0;
+    let curObjPtr = null;
+    let curFont = null;
+    let curFontSize = 0;
+    let curColor = null;
+    let bounds = null;
+    const flushRun = (end) => {
+      if (curObjPtr === null || curFont === null || curColor === null || bounds === null) return;
+      const count = end - runStart;
+      if (count <= 0) return;
+      const bufPtr = this.memoryManager.malloc(2 * (count + 1));
+      this.pdfiumModule.FPDFText_GetText(textPagePtr, runStart, count, bufPtr);
+      const text = stripPdfUnwantedMarkers(this.pdfiumModule.pdfium.UTF16ToString(bufPtr));
+      this.memoryManager.free(bufPtr);
+      runs.push({
+        text,
+        rect: {
+          origin: { x: bounds.minX, y: bounds.minY },
+          size: {
+            width: Math.max(1, bounds.maxX - bounds.minX),
+            height: Math.max(1, bounds.maxY - bounds.minY)
+          }
+        },
+        font: curFont,
+        fontSize: curFontSize,
+        color: curColor,
+        charIndex: runStart,
+        charCount: count
+      });
+    };
+    const rPtr = this.memoryManager.malloc(4);
+    const gPtr = this.memoryManager.malloc(4);
+    const bPtr = this.memoryManager.malloc(4);
+    const aPtr = this.memoryManager.malloc(4);
+    const rectPtr = this.memoryManager.malloc(16);
+    const dx1Ptr = this.memoryManager.malloc(4);
+    const dy1Ptr = this.memoryManager.malloc(4);
+    const dx2Ptr = this.memoryManager.malloc(4);
+    const dy2Ptr = this.memoryManager.malloc(4);
+    const italicAnglePtr = this.memoryManager.malloc(4);
+    for (let i = 0; i < charCount; i++) {
+      const uc = this.pdfiumModule.FPDFText_GetUnicode(textPagePtr, i);
+      if (uc === 65534 || uc === 65533) continue;
+      const objPtr = this.pdfiumModule.FPDFText_GetTextObject(textPagePtr, i);
+      if (objPtr === 0) continue;
+      const fontSize = this.pdfiumModule.FPDFText_GetFontSize(textPagePtr, i);
+      this.pdfiumModule.FPDFText_GetFillColor(textPagePtr, i, rPtr, gPtr, bPtr, aPtr);
+      const red = this.pdfiumModule.pdfium.getValue(rPtr, "i32") & 255;
+      const green = this.pdfiumModule.pdfium.getValue(gPtr, "i32") & 255;
+      const blue = this.pdfiumModule.pdfium.getValue(bPtr, "i32") & 255;
+      const alpha = this.pdfiumModule.pdfium.getValue(aPtr, "i32") & 255;
+      const fontInfo = this.readFontInfoFromTextObject(objPtr, italicAnglePtr);
+      const needNewRun = curObjPtr === null || objPtr !== curObjPtr || fontInfo.name !== curFont.name || Math.abs(fontSize - curFontSize) > 0.01 || red !== curColor.red || green !== curColor.green || blue !== curColor.blue;
+      if (needNewRun) {
+        flushRun(i);
+        curObjPtr = objPtr;
+        curFont = fontInfo;
+        curFontSize = fontSize;
+        curColor = { red, green, blue, alpha };
+        runStart = i;
+        bounds = null;
+      }
+      if (this.pdfiumModule.FPDFText_GetLooseCharBox(textPagePtr, i, rectPtr)) {
+        const left = this.pdfiumModule.pdfium.getValue(rectPtr, "float");
+        const top = this.pdfiumModule.pdfium.getValue(rectPtr + 4, "float");
+        const right = this.pdfiumModule.pdfium.getValue(rectPtr + 8, "float");
+        const bottom = this.pdfiumModule.pdfium.getValue(rectPtr + 12, "float");
+        if (left !== right && top !== bottom) {
+          this.pdfiumModule.FPDF_PageToDevice(
+            pageCtx.pagePtr,
+            0,
+            0,
+            page.size.width,
+            page.size.height,
+            0,
+            left,
+            top,
+            dx1Ptr,
+            dy1Ptr
+          );
+          this.pdfiumModule.FPDF_PageToDevice(
+            pageCtx.pagePtr,
+            0,
+            0,
+            page.size.width,
+            page.size.height,
+            0,
+            right,
+            bottom,
+            dx2Ptr,
+            dy2Ptr
+          );
+          const x1 = this.pdfiumModule.pdfium.getValue(dx1Ptr, "i32");
+          const y1 = this.pdfiumModule.pdfium.getValue(dy1Ptr, "i32");
+          const x2 = this.pdfiumModule.pdfium.getValue(dx2Ptr, "i32");
+          const y2 = this.pdfiumModule.pdfium.getValue(dy2Ptr, "i32");
+          const cx = Math.min(x1, x2);
+          const cy = Math.min(y1, y2);
+          const cw = Math.abs(x2 - x1);
+          const ch = Math.abs(y2 - y1);
+          if (bounds === null) {
+            bounds = { minX: cx, minY: cy, maxX: cx + cw, maxY: cy + ch };
+          } else {
+            bounds.minX = Math.min(bounds.minX, cx);
+            bounds.minY = Math.min(bounds.minY, cy);
+            bounds.maxX = Math.max(bounds.maxX, cx + cw);
+            bounds.maxY = Math.max(bounds.maxY, cy + ch);
+          }
+        }
+      }
+    }
+    flushRun(charCount);
+    [rPtr, gPtr, bPtr, aPtr, rectPtr, dx1Ptr, dy1Ptr, dx2Ptr, dy2Ptr, italicAnglePtr].forEach(
+      (p) => this.memoryManager.free(p)
+    );
+    pageCtx.release();
+    this.logger.perf(LOG_SOURCE, LOG_CATEGORY, label, "End", doc.id);
+    return PdfTaskHelper.resolve({ runs });
+  }
+  /**
+   * Read font metadata from a text object handle via FPDFFont_* APIs.
+   */
+  readFontInfoFromTextObject(textObjPtr, italicAnglePtr) {
+    const fontPtr = this.pdfiumModule.FPDFTextObj_GetFont(textObjPtr);
+    let name = "";
+    let familyName = "";
+    let weight = 400;
+    let italic = false;
+    let monospaced = false;
+    let embedded = false;
+    if (fontPtr) {
+      const nameLen = this.pdfiumModule.FPDFFont_GetBaseFontName(fontPtr, 0, 0);
+      if (nameLen > 0) {
+        const nameBuf = this.memoryManager.malloc(nameLen + 1);
+        this.pdfiumModule.FPDFFont_GetBaseFontName(fontPtr, nameBuf, nameLen + 1);
+        name = this.pdfiumModule.pdfium.UTF8ToString(nameBuf);
+        this.memoryManager.free(nameBuf);
+      }
+      const famLen = this.pdfiumModule.FPDFFont_GetFamilyName(fontPtr, 0, 0);
+      if (famLen > 0) {
+        const famBuf = this.memoryManager.malloc(famLen + 1);
+        this.pdfiumModule.FPDFFont_GetFamilyName(fontPtr, famBuf, famLen + 1);
+        familyName = this.pdfiumModule.pdfium.UTF8ToString(famBuf);
+        this.memoryManager.free(famBuf);
+      }
+      weight = this.pdfiumModule.FPDFFont_GetWeight(fontPtr);
+      embedded = this.pdfiumModule.FPDFFont_GetIsEmbedded(fontPtr) !== 0;
+      if (this.pdfiumModule.FPDFFont_GetItalicAngle(fontPtr, italicAnglePtr)) {
+        const angle = this.pdfiumModule.pdfium.getValue(italicAnglePtr, "i32");
+        italic = angle !== 0;
+      }
+      const flags = this.pdfiumModule.FPDFFont_GetFlags(fontPtr);
+      monospaced = (flags & 1) !== 0;
+    }
+    return { name, familyName, weight, italic, monospaced, embedded };
+  }
   /**
    * Extract glyph geometry + metadata for `charIndex`
    *
@@ -3781,14 +3962,31 @@ class PdfiumNative {
     const dx2Ptr = this.memoryManager.malloc(4);
     const dy2Ptr = this.memoryManager.malloc(4);
     const rectPtr = this.memoryManager.malloc(16);
+    const tLeftPtr = this.memoryManager.malloc(8);
+    const tRightPtr = this.memoryManager.malloc(8);
+    const tBottomPtr = this.memoryManager.malloc(8);
+    const tTopPtr = this.memoryManager.malloc(8);
+    const allPtrs = [
+      rectPtr,
+      dx1Ptr,
+      dy1Ptr,
+      dx2Ptr,
+      dy2Ptr,
+      tLeftPtr,
+      tRightPtr,
+      tBottomPtr,
+      tTopPtr
+    ];
     let x = 0, y = 0, width = 0, height = 0, isSpace = false;
+    let tightOrigin;
+    let tightSize;
     if (this.pdfiumModule.FPDFText_GetLooseCharBox(textPagePtr, charIndex, rectPtr)) {
       const left = this.pdfiumModule.pdfium.getValue(rectPtr, "float");
       const top = this.pdfiumModule.pdfium.getValue(rectPtr + 4, "float");
       const right = this.pdfiumModule.pdfium.getValue(rectPtr + 8, "float");
       const bottom = this.pdfiumModule.pdfium.getValue(rectPtr + 12, "float");
       if (left === right || top === bottom) {
-        [rectPtr, dx1Ptr, dy1Ptr, dx2Ptr, dy2Ptr].forEach((p) => this.memoryManager.free(p));
+        allPtrs.forEach((p) => this.memoryManager.free(p));
         return {
           origin: { x: 0, y: 0 },
           size: { width: 0, height: 0 },
@@ -3801,7 +3999,6 @@ class PdfiumNative {
         0,
         page.size.width,
         page.size.height,
-        /*rotate=*/
         0,
         left,
         top,
@@ -3814,7 +4011,6 @@ class PdfiumNative {
         0,
         page.size.width,
         page.size.height,
-        /*rotate=*/
         0,
         right,
         bottom,
@@ -3829,13 +4025,61 @@ class PdfiumNative {
       y = Math.min(y1, y2);
       width = Math.max(1, Math.abs(x2 - x1));
       height = Math.max(1, Math.abs(y2 - y1));
+      if (this.pdfiumModule.FPDFText_GetCharBox(
+        textPagePtr,
+        charIndex,
+        tLeftPtr,
+        tRightPtr,
+        tBottomPtr,
+        tTopPtr
+      )) {
+        const tLeft = this.pdfiumModule.pdfium.getValue(tLeftPtr, "double");
+        const tRight = this.pdfiumModule.pdfium.getValue(tRightPtr, "double");
+        const tBottom = this.pdfiumModule.pdfium.getValue(tBottomPtr, "double");
+        const tTop = this.pdfiumModule.pdfium.getValue(tTopPtr, "double");
+        this.pdfiumModule.FPDF_PageToDevice(
+          pagePtr,
+          0,
+          0,
+          page.size.width,
+          page.size.height,
+          0,
+          tLeft,
+          tTop,
+          dx1Ptr,
+          dy1Ptr
+        );
+        this.pdfiumModule.FPDF_PageToDevice(
+          pagePtr,
+          0,
+          0,
+          page.size.width,
+          page.size.height,
+          0,
+          tRight,
+          tBottom,
+          dx2Ptr,
+          dy2Ptr
+        );
+        const tx1 = this.pdfiumModule.pdfium.getValue(dx1Ptr, "i32");
+        const ty1 = this.pdfiumModule.pdfium.getValue(dy1Ptr, "i32");
+        const tx2 = this.pdfiumModule.pdfium.getValue(dx2Ptr, "i32");
+        const ty2 = this.pdfiumModule.pdfium.getValue(dy2Ptr, "i32");
+        tightOrigin = { x: Math.min(tx1, tx2), y: Math.min(ty1, ty2) };
+        tightSize = {
+          width: Math.max(1, Math.abs(tx2 - tx1)),
+          height: Math.max(1, Math.abs(ty2 - ty1))
+        };
+      }
       const uc = this.pdfiumModule.FPDFText_GetUnicode(textPagePtr, charIndex);
       isSpace = uc === 32;
     }
-    [rectPtr, dx1Ptr, dy1Ptr, dx2Ptr, dy2Ptr].forEach((p) => this.memoryManager.free(p));
+    allPtrs.forEach((p) => this.memoryManager.free(p));
     return {
       origin: { x, y },
       size: { width, height },
+      ...tightOrigin && { tightOrigin },
+      ...tightSize && { tightSize },
       ...isSpace && { isSpace }
     };
   }
@@ -7488,7 +7732,7 @@ class PdfiumNative {
       right: 0,
       bottom: 0
     };
-    if (this.pdfiumModule.FPDFAnnot_GetRect(annotationPtr, pageRectPtr)) {
+    if (this.pdfiumModule.EPDFAnnot_GetRect(annotationPtr, pageRectPtr)) {
       pageRect.left = this.pdfiumModule.pdfium.getValue(pageRectPtr, "float");
       pageRect.top = this.pdfiumModule.pdfium.getValue(pageRectPtr + 4, "float");
       pageRect.right = this.pdfiumModule.pdfium.getValue(pageRectPtr + 8, "float");
@@ -8020,4 +8264,4 @@ export {
   isValidCustomKey as i,
   readArrayBuffer as r
 };
-//# sourceMappingURL=direct-engine-CvfzIn2D.js.map
+//# sourceMappingURL=direct-engine-CmsmBgWP.js.map