@embedpdf/engines 2.0.1 → 2.1.0

package/dist/{direct-engine-DuLFAbiv.js → direct-engine-CB3k-o0I.js}

@@ -380,8 +380,8 @@ const MEMORY_LIMITS = {
 const LIMITS = {
   MEMORY: MEMORY_LIMITS
 };
-const LOG_SOURCE$1 = "PDFiumEngine";
-const LOG_CATEGORY$1 = "MemoryManager";
+const LOG_SOURCE$2 = "PDFiumEngine";
+const LOG_CATEGORY$2 = "MemoryManager";
 class MemoryManager {
   constructor(pdfiumModule, logger) {
     this.pdfiumModule = pdfiumModule;
@@ -418,7 +418,7 @@ class MemoryManager {
   free(ptr) {
     const allocation = this.allocations.get(ptr);
     if (!allocation) {
-      this.logger.warn(LOG_SOURCE$1, LOG_CATEGORY$1, `Freeing untracked pointer: ${ptr}`);
+      this.logger.warn(LOG_SOURCE$2, LOG_CATEGORY$2, `Freeing untracked pointer: ${ptr}`);
     } else {
       this.totalAllocated -= allocation.size;
       this.allocations.delete(ptr);
@@ -441,16 +441,494 @@ class MemoryManager {
   checkLeaks() {
     if (this.allocations.size > 0) {
       this.logger.warn(
-        LOG_SOURCE$1,
-        LOG_CATEGORY$1,
+        LOG_SOURCE$2,
+        LOG_CATEGORY$2,
         `Potential memory leak: ${this.allocations.size} unfreed allocations`
       );
       for (const [ptr, alloc] of this.allocations) {
-        this.logger.warn(LOG_SOURCE$1, LOG_CATEGORY$1, `  - ${ptr}: ${alloc.size} bytes`, alloc.stack);
+        this.logger.warn(LOG_SOURCE$2, LOG_CATEGORY$2, `  - ${ptr}: ${alloc.size} bytes`, alloc.stack);
+      }
+    }
+  }
+}
+const SYSFONTINFO_SIZE = 36;
+const OFFSET_VERSION = 0;
+const OFFSET_RELEASE = 4;
+const OFFSET_ENUMFONTS = 8;
+const OFFSET_MAPFONT = 12;
+const OFFSET_GETFONT = 16;
+const OFFSET_GETFONTDATA = 20;
+const OFFSET_GETFACENAME = 24;
+const OFFSET_GETFONTCHARSET = 28;
+const OFFSET_DELETEFONT = 32;
+const LOG_SOURCE$1 = "pdfium";
+const LOG_CATEGORY$1 = "font-fallback";
+class FontFallbackManager {
+  constructor(config, logger = new NoopLogger()) {
+    this.fontHandles = /* @__PURE__ */ new Map();
+    this.fontCache = /* @__PURE__ */ new Map();
+    this.nextHandleId = 1;
+    this.module = null;
+    this.enabled = false;
+    this.structPtr = 0;
+    this.releaseFnPtr = 0;
+    this.enumFontsFnPtr = 0;
+    this.mapFontFnPtr = 0;
+    this.getFontFnPtr = 0;
+    this.getFontDataFnPtr = 0;
+    this.getFaceNameFnPtr = 0;
+    this.getFontCharsetFnPtr = 0;
+    this.deleteFontFnPtr = 0;
+    this.fontConfig = config;
+    this.logger = logger;
+  }
+  /**
+   * Initialize the font fallback system and attach to PDFium module
+   */
+  initialize(module) {
+    if (this.enabled) {
+      this.logger.warn(LOG_SOURCE$1, LOG_CATEGORY$1, "Font fallback already initialized");
+      return;
+    }
+    this.module = module;
+    const pdfium = module.pdfium;
+    if (typeof pdfium.addFunction !== "function") {
+      this.logger.error(
+        LOG_SOURCE$1,
+        LOG_CATEGORY$1,
+        "addFunction not available. Make sure WASM is compiled with -sALLOW_TABLE_GROWTH"
+      );
+      return;
+    }
+    try {
+      this.structPtr = pdfium.wasmExports.malloc(SYSFONTINFO_SIZE);
+      if (!this.structPtr) {
+        throw new Error("Failed to allocate FPDF_SYSFONTINFO struct");
+      }
+      for (let i = 0; i < SYSFONTINFO_SIZE; i++) {
+        pdfium.setValue(this.structPtr + i, 0, "i8");
+      }
+      this.releaseFnPtr = pdfium.addFunction((_pThis) => {
+      }, "vi");
+      this.enumFontsFnPtr = pdfium.addFunction((_pThis, _pMapper) => {
+      }, "vii");
+      this.mapFontFnPtr = pdfium.addFunction(
+        (_pThis, weight, bItalic, charset, pitchFamily, facePtr, bExactPtr) => {
+          const face = facePtr ? pdfium.UTF8ToString(facePtr) : "";
+          const handle = this.mapFont(weight, bItalic, charset, pitchFamily, face);
+          if (bExactPtr) {
+            pdfium.setValue(bExactPtr, 0, "i32");
+          }
+          return handle;
+        },
+        "iiiiiiii"
+      );
+      this.getFontFnPtr = pdfium.addFunction((_pThis, facePtr) => {
+        const face = facePtr ? pdfium.UTF8ToString(facePtr) : "";
+        return this.mapFont(400, 0, 0, 0, face);
+      }, "iii");
+      this.getFontDataFnPtr = pdfium.addFunction(
+        (_pThis, hFont, table, buffer, bufSize) => {
+          return this.getFontData(hFont, table, buffer, bufSize);
+        },
+        "iiiiii"
+      );
+      this.getFaceNameFnPtr = pdfium.addFunction(
+        (_pThis, _hFont, _buffer, _bufSize) => {
+          return 0;
+        },
+        "iiiii"
+      );
+      this.getFontCharsetFnPtr = pdfium.addFunction((_pThis, hFont) => {
+        const handle = this.fontHandles.get(hFont);
+        return (handle == null ? void 0 : handle.charset) ?? 0;
+      }, "iii");
+      this.deleteFontFnPtr = pdfium.addFunction((_pThis, hFont) => {
+        this.deleteFont(hFont);
+      }, "vii");
+      pdfium.setValue(this.structPtr + OFFSET_VERSION, 1, "i32");
+      pdfium.setValue(this.structPtr + OFFSET_RELEASE, this.releaseFnPtr, "i32");
+      pdfium.setValue(this.structPtr + OFFSET_ENUMFONTS, this.enumFontsFnPtr, "i32");
+      pdfium.setValue(this.structPtr + OFFSET_MAPFONT, this.mapFontFnPtr, "i32");
+      pdfium.setValue(this.structPtr + OFFSET_GETFONT, this.getFontFnPtr, "i32");
+      pdfium.setValue(this.structPtr + OFFSET_GETFONTDATA, this.getFontDataFnPtr, "i32");
+      pdfium.setValue(this.structPtr + OFFSET_GETFACENAME, this.getFaceNameFnPtr, "i32");
+      pdfium.setValue(this.structPtr + OFFSET_GETFONTCHARSET, this.getFontCharsetFnPtr, "i32");
+      pdfium.setValue(this.structPtr + OFFSET_DELETEFONT, this.deleteFontFnPtr, "i32");
+      module.FPDF_SetSystemFontInfo(this.structPtr);
+      this.enabled = true;
+      this.logger.info(
+        LOG_SOURCE$1,
+        LOG_CATEGORY$1,
+        "Font fallback system initialized (pure TypeScript)",
+        Object.keys(this.fontConfig.fonts)
+      );
+    } catch (error) {
+      this.logger.error(LOG_SOURCE$1, LOG_CATEGORY$1, "Failed to initialize font fallback", error);
+      this.cleanup();
+      throw error;
+    }
+  }
+  /**
+   * Disable the font fallback system and clean up resources
+   */
+  disable() {
+    if (!this.enabled || !this.module) {
+      return;
+    }
+    this.module.FPDF_SetSystemFontInfo(0);
+    this.cleanup();
+    this.enabled = false;
+    this.logger.debug(LOG_SOURCE$1, LOG_CATEGORY$1, "Font fallback system disabled");
+  }
+  /**
+   * Clean up allocated resources
+   */
+  cleanup() {
+    if (!this.module) return;
+    const pdfium = this.module.pdfium;
+    if (this.structPtr) {
+      pdfium.wasmExports.free(this.structPtr);
+      this.structPtr = 0;
+    }
+    const removeIfExists = (ptr) => {
+      if (ptr && typeof pdfium.removeFunction === "function") {
+        try {
+          pdfium.removeFunction(ptr);
+        } catch {
+        }
+      }
+    };
+    removeIfExists(this.releaseFnPtr);
+    removeIfExists(this.enumFontsFnPtr);
+    removeIfExists(this.mapFontFnPtr);
+    removeIfExists(this.getFontFnPtr);
+    removeIfExists(this.getFontDataFnPtr);
+    removeIfExists(this.getFaceNameFnPtr);
+    removeIfExists(this.getFontCharsetFnPtr);
+    removeIfExists(this.deleteFontFnPtr);
+    this.releaseFnPtr = 0;
+    this.enumFontsFnPtr = 0;
+    this.mapFontFnPtr = 0;
+    this.getFontFnPtr = 0;
+    this.getFontDataFnPtr = 0;
+    this.getFaceNameFnPtr = 0;
+    this.getFontCharsetFnPtr = 0;
+    this.deleteFontFnPtr = 0;
+  }
+  /**
+   * Check if font fallback is enabled
+   */
+  isEnabled() {
+    return this.enabled;
+  }
+  /**
+   * Get statistics about font loading
+   */
+  getStats() {
+    return {
+      handleCount: this.fontHandles.size,
+      cacheSize: this.fontCache.size,
+      cachedUrls: Array.from(this.fontCache.keys())
+    };
+  }
+  /**
+   * Pre-load fonts for specific charsets (optional optimization)
+   * This can be called to warm the cache before rendering
+   */
+  async preloadFonts(charsets) {
+    const urls = charsets.map((charset) => this.getFontUrlForCharset(charset)).filter((url) => url !== null);
+    const uniqueUrls = [...new Set(urls)];
+    await Promise.all(
+      uniqueUrls.map(async (url) => {
+        if (!this.fontCache.has(url)) {
+          try {
+            const data = await this.fetchFontAsync(url);
+            if (data) {
+              this.fontCache.set(url, data);
+              this.logger.debug(LOG_SOURCE$1, LOG_CATEGORY$1, `Pre-loaded font: ${url}`);
+            }
+          } catch (error) {
+            this.logger.warn(LOG_SOURCE$1, LOG_CATEGORY$1, `Failed to pre-load font: ${url}`, error);
+          }
+        }
+      })
+    );
+  }
+  // ============================================================================
+  // PDFium Callback Implementations
+  // ============================================================================
+  /**
+   * MapFont - called by PDFium when it needs a font
+   */
+  mapFont(weight, bItalic, charset, pitchFamily, face) {
+    const italic = bItalic !== 0;
+    this.logger.debug(LOG_SOURCE$1, LOG_CATEGORY$1, "MapFont called", {
+      weight,
+      italic,
+      charset,
+      pitchFamily,
+      face
+    });
+    const result = this.findBestFontMatch(charset, weight, italic);
+    if (!result) {
+      this.logger.debug(LOG_SOURCE$1, LOG_CATEGORY$1, `No font configured for charset ${charset}`);
+      return 0;
+    }
+    const handle = {
+      id: this.nextHandleId++,
+      charset,
+      weight,
+      italic,
+      url: result.url,
+      data: null
+    };
+    this.fontHandles.set(handle.id, handle);
+    this.logger.debug(
+      LOG_SOURCE$1,
+      LOG_CATEGORY$1,
+      `Created font handle ${handle.id} for ${result.url} (requested: weight=${weight}, italic=${italic}, matched: weight=${result.matchedWeight}, italic=${result.matchedItalic})`
+    );
+    return handle.id;
+  }
+  /**
+   * GetFontData - called by PDFium to get font bytes
+   */
+  getFontData(fontHandle, table, bufferPtr, bufSize) {
+    const handle = this.fontHandles.get(fontHandle);
+    if (!handle) {
+      this.logger.warn(LOG_SOURCE$1, LOG_CATEGORY$1, `Unknown font handle: ${fontHandle}`);
+      return 0;
+    }
+    if (!handle.data) {
+      if (this.fontCache.has(handle.url)) {
+        handle.data = this.fontCache.get(handle.url);
+      } else {
+        handle.data = this.fetchFontSync(handle.url);
+        if (handle.data) {
+          this.fontCache.set(handle.url, handle.data);
+        }
+      }
+    }
+    if (!handle.data) {
+      this.logger.warn(LOG_SOURCE$1, LOG_CATEGORY$1, `Failed to load font: ${handle.url}`);
+      return 0;
+    }
+    const fontData = handle.data;
+    if (table !== 0) {
+      this.logger.debug(
+        LOG_SOURCE$1,
+        LOG_CATEGORY$1,
+        `Table ${table} requested - returning 0 to request whole file`
+      );
+      return 0;
+    }
+    if (bufferPtr === 0 || bufSize < fontData.length) {
+      return fontData.length;
+    }
+    if (this.module) {
+      const heap = this.module.pdfium.HEAPU8;
+      heap.set(fontData, bufferPtr);
+      this.logger.debug(
+        LOG_SOURCE$1,
+        LOG_CATEGORY$1,
+        `Copied ${fontData.length} bytes to buffer for handle ${fontHandle}`
+      );
+    }
+    return fontData.length;
+  }
+  /**
+   * DeleteFont - called by PDFium when done with a font
+   */
+  deleteFont(fontHandle) {
+    const handle = this.fontHandles.get(fontHandle);
+    if (handle) {
+      this.logger.debug(LOG_SOURCE$1, LOG_CATEGORY$1, `Deleting font handle ${fontHandle}`);
+      this.fontHandles.delete(fontHandle);
+    }
+  }
+  // ============================================================================
+  // Helper Methods
+  // ============================================================================
+  /**
+   * Find the best matching font variant for the given parameters
+   */
+  findBestFontMatch(charset, requestedWeight, requestedItalic) {
+    const { fonts, defaultFont, baseUrl } = this.fontConfig;
+    const entry = fonts[charset] ?? defaultFont;
+    if (!entry) {
+      return null;
+    }
+    const variants = this.normalizeToVariants(entry);
+    if (variants.length === 0) {
+      return null;
+    }
+    const best = this.selectBestVariant(variants, requestedWeight, requestedItalic);
+    let url = best.url;
+    if (baseUrl && !url.startsWith("http://") && !url.startsWith("https://") && !url.startsWith("/")) {
+      url = `${baseUrl}/${url}`;
+    }
+    return {
+      url,
+      matchedWeight: best.weight ?? 400,
+      matchedItalic: best.italic ?? false
+    };
+  }
+  /**
+   * Normalize a FontEntry to an array of FontVariants
+   */
+  normalizeToVariants(entry) {
+    if (typeof entry === "string") {
+      return [{ url: entry, weight: 400, italic: false }];
+    }
+    if (Array.isArray(entry)) {
+      return entry.map((v) => ({
+        url: v.url,
+        weight: v.weight ?? 400,
+        italic: v.italic ?? false
+      }));
+    }
+    return [{ url: entry.url, weight: entry.weight ?? 400, italic: entry.italic ?? false }];
+  }
+  /**
+   * Select the best matching variant based on weight and italic
+   * Uses CSS font matching algorithm principles:
+   * 1. Exact italic match preferred
+   * 2. Closest weight (with bias toward bolder for weights >= 400)
+   */
+  selectBestVariant(variants, requestedWeight, requestedItalic) {
+    if (variants.length === 1) {
+      return variants[0];
+    }
+    const italicMatches = variants.filter((v) => (v.italic ?? false) === requestedItalic);
+    const candidates = italicMatches.length > 0 ? italicMatches : variants;
+    let bestMatch = candidates[0];
+    let bestDistance = Math.abs((bestMatch.weight ?? 400) - requestedWeight);
+    for (const variant of candidates) {
+      const variantWeight = variant.weight ?? 400;
+      const distance = Math.abs(variantWeight - requestedWeight);
+      if (distance < bestDistance) {
+        bestMatch = variant;
+        bestDistance = distance;
+      } else if (distance === bestDistance) {
+        const currentWeight = bestMatch.weight ?? 400;
+        if (requestedWeight >= 500) {
+          if (variantWeight > currentWeight) {
+            bestMatch = variant;
+          }
+        } else {
+          if (variantWeight < currentWeight) {
+            bestMatch = variant;
+          }
+        }
+      }
+    }
+    return bestMatch;
+  }
+  /**
+   * Get font URL for a charset (backward compatible helper)
+   */
+  getFontUrlForCharset(charset) {
+    const result = this.findBestFontMatch(charset, 400, false);
+    return (result == null ? void 0 : result.url) ?? null;
+  }
+  /**
+   * Fetch font data synchronously
+   * Uses custom fontLoader if provided, otherwise falls back to XMLHttpRequest (browser)
+   */
+  fetchFontSync(pathOrUrl) {
+    this.logger.debug(LOG_SOURCE$1, LOG_CATEGORY$1, `Fetching font synchronously: ${pathOrUrl}`);
+    if (this.fontConfig.fontLoader) {
+      try {
+        const data = this.fontConfig.fontLoader(pathOrUrl);
+        if (data) {
+          this.logger.info(
+            LOG_SOURCE$1,
+            LOG_CATEGORY$1,
+            `Loaded font via custom loader: ${pathOrUrl} (${data.length} bytes)`
+          );
+        } else {
+          this.logger.warn(
+            LOG_SOURCE$1,
+            LOG_CATEGORY$1,
+            `Custom font loader returned null for: ${pathOrUrl}`
+          );
+        }
+        return data;
+      } catch (error) {
+        this.logger.error(
+          LOG_SOURCE$1,
+          LOG_CATEGORY$1,
+          `Error in custom font loader: ${pathOrUrl}`,
+          error
+        );
+        return null;
+      }
+    }
+    try {
+      const xhr = new XMLHttpRequest();
+      xhr.open("GET", pathOrUrl, false);
+      xhr.responseType = "arraybuffer";
+      xhr.send();
+      if (xhr.status === 200) {
+        const data = new Uint8Array(xhr.response);
+        this.logger.info(
+          LOG_SOURCE$1,
+          LOG_CATEGORY$1,
+          `Loaded font: ${pathOrUrl} (${data.length} bytes)`
+        );
+        return data;
+      } else {
+        this.logger.error(
+          LOG_SOURCE$1,
+          LOG_CATEGORY$1,
+          `Failed to load font: ${pathOrUrl} (HTTP ${xhr.status})`
+        );
+        return null;
+      }
+    } catch (error) {
+      this.logger.error(LOG_SOURCE$1, LOG_CATEGORY$1, `Error fetching font: ${pathOrUrl}`, error);
+      return null;
+    }
+  }
+  /**
+   * Fetch font data asynchronously (for preloading)
+   * Uses custom fontLoader if provided, otherwise falls back to fetch API
+   */
+  async fetchFontAsync(pathOrUrl) {
+    if (this.fontConfig.fontLoader) {
+      try {
+        return this.fontConfig.fontLoader(pathOrUrl);
+      } catch {
+        return null;
       }
     }
+    try {
+      const response = await fetch(pathOrUrl);
+      if (response.ok) {
+        const buffer = await response.arrayBuffer();
+        return new Uint8Array(buffer);
+      }
+      return null;
+    } catch {
+      return null;
+    }
   }
 }
+function createNodeFontLoader(fs, path, basePath) {
+  return (fontPath) => {
+    try {
+      const fullPath = path.join(basePath, fontPath);
+      const data = fs.readFileSync(fullPath);
+      if (data instanceof Uint8Array) {
+        return data;
+      }
+      return new Uint8Array(data);
+    } catch {
+      return null;
+    }
+  };
+}
 var BitmapFormat = /* @__PURE__ */ ((BitmapFormat2) => {
   BitmapFormat2[BitmapFormat2["Bitmap_Gray"] = 1] = "Bitmap_Gray";
   BitmapFormat2[BitmapFormat2["Bitmap_BGR"] = 2] = "Bitmap_BGR";
@@ -494,7 +972,8 @@ class PdfiumNative {
   constructor(pdfiumModule, options = {}) {
     this.pdfiumModule = pdfiumModule;
     this.memoryLeakCheckInterval = null;
-    const { logger = new NoopLogger() } = options;
+    this.fontFallbackManager = null;
+    const { logger = new NoopLogger(), fontFallback } = options;
     this.logger = logger;
     this.memoryManager = new MemoryManager(this.pdfiumModule, this.logger);
     this.cache = new PdfCache(this.pdfiumModule, this.memoryManager);
@@ -507,6 +986,11 @@ class PdfiumNative {
     this.logger.perf(LOG_SOURCE, LOG_CATEGORY, `Initialize`, "Begin", "General");
     this.pdfiumModule.PDFiumExt_Init();
     this.logger.perf(LOG_SOURCE, LOG_CATEGORY, `Initialize`, "End", "General");
+    if (fontFallback) {
+      this.fontFallbackManager = new FontFallbackManager(fontFallback, this.logger);
+      this.fontFallbackManager.initialize(this.pdfiumModule);
+      this.logger.info(LOG_SOURCE, LOG_CATEGORY, "Font fallback system enabled");
+    }
   }
   /**
    * {@inheritDoc @embedpdf/models!PdfEngine.destroy}
@@ -516,6 +1000,10 @@ class PdfiumNative {
   destroy() {
     this.logger.debug(LOG_SOURCE, LOG_CATEGORY, "destroy");
     this.logger.perf(LOG_SOURCE, LOG_CATEGORY, `Destroy`, "Begin", "General");
+    if (this.fontFallbackManager) {
+      this.fontFallbackManager.disable();
+      this.fontFallbackManager = null;
+    }
     this.pdfiumModule.FPDF_DestroyLibrary();
     if (this.memoryLeakCheckInterval) {
       clearInterval(this.memoryLeakCheckInterval);
@@ -524,6 +1012,13 @@ class PdfiumNative {
     this.logger.perf(LOG_SOURCE, LOG_CATEGORY, `Destroy`, "End", "General");
     return PdfTaskHelper.resolve(true);
   }
+  /**
+   * Get the font fallback manager instance
+   * Useful for pre-loading fonts or checking stats
+   */
+  getFontFallbackManager() {
+    return this.fontFallbackManager;
+  }
   /** Write a UTF-16LE (WIDESTRING) to wasm, call `fn(ptr)`, then free. */
   withWString(value, fn) {
     const length = (value.length + 1) * 2;
@@ -2108,6 +2603,9 @@ class PdfiumNative {
     if (!this.setAnnotString(annotationPtr, "Contents", annotation.contents ?? "")) {
       return false;
     }
+    if (annotation.custom && !this.setAnnotCustom(annotationPtr, annotation.custom)) {
+      return false;
+    }
     if (!this.setAnnotString(annotationPtr, "T", annotation.author || "")) {
       return false;
     }
@@ -2148,6 +2646,9 @@ class PdfiumNative {
     if (annotation.created && !this.setAnnotationDate(annotationPtr, "CreationDate", annotation.created)) {
       return false;
     }
+    if (annotation.custom && !this.setAnnotCustom(annotationPtr, annotation.custom)) {
+      return false;
+    }
     if (annotation.flags && !this.setAnnotationFlags(annotationPtr, annotation.flags)) {
       return false;
     }
@@ -2210,6 +2711,9 @@ class PdfiumNative {
     if (annotation.created && !this.setAnnotationDate(annotationPtr, "CreationDate", annotation.created)) {
       return false;
     }
+    if (annotation.custom && !this.setAnnotCustom(annotationPtr, annotation.custom)) {
+      return false;
+    }
     if (annotation.flags && !this.setAnnotationFlags(annotationPtr, annotation.flags)) {
       return false;
     }
@@ -2255,6 +2759,9 @@ class PdfiumNative {
     if (annotation.created && !this.setAnnotationDate(annotationPtr, "CreationDate", annotation.created)) {
       return false;
     }
+    if (annotation.custom && !this.setAnnotCustom(annotationPtr, annotation.custom)) {
+      return false;
+    }
     if (annotation.flags && !this.setAnnotationFlags(annotationPtr, annotation.flags)) {
       return false;
     }
@@ -2329,6 +2836,9 @@ class PdfiumNative {
     if (annotation.created && !this.setAnnotationDate(annotationPtr, "CreationDate", annotation.created)) {
       return false;
     }
+    if (annotation.custom && !this.setAnnotCustom(annotationPtr, annotation.custom)) {
+      return false;
+    }
     if (annotation.modified && !this.setAnnotationDate(annotationPtr, "M", annotation.modified)) {
       return false;
     }
@@ -2397,6 +2907,9 @@ class PdfiumNative {
     if (annotation.created && !this.setAnnotationDate(annotationPtr, "CreationDate", annotation.created)) {
       return false;
     }
+    if (annotation.custom && !this.setAnnotCustom(annotationPtr, annotation.custom)) {
+      return false;
+    }
     if (annotation.modified && !this.setAnnotationDate(annotationPtr, "M", annotation.modified)) {
       return false;
     }
@@ -2497,6 +3010,9 @@ class PdfiumNative {
     if (annotation.created && !this.setAnnotationDate(annotationPtr, "CreationDate", annotation.created)) {
       return false;
     }
+    if (annotation.custom && !this.setAnnotCustom(annotationPtr, annotation.custom)) {
+      return false;
+    }
     if (annotation.flags && !this.setAnnotationFlags(annotationPtr, annotation.flags)) {
       return false;
     }
@@ -2506,6 +3022,9 @@ class PdfiumNative {
     if (annotation.icon && !this.setAnnotationIcon(annotationPtr, annotation.icon)) {
       return false;
     }
+    if (!this.setAnnotString(annotationPtr, "T", annotation.author || "")) {
+      return false;
+    }
     if (annotation.subject && !this.setAnnotString(annotationPtr, "Subj", annotation.subject)) {
       return false;
     }
@@ -6764,7 +7283,10 @@ async function createPdfiumEngine(wasmUrl, options) {
   const response = await fetch(wasmUrl);
   const wasmBinary = await response.arrayBuffer();
   const wasmModule = await init({ wasmBinary });
-  const native = new PdfiumNative(wasmModule, { logger: options == null ? void 0 : options.logger });
+  const native = new PdfiumNative(wasmModule, {
+    logger: options == null ? void 0 : options.logger,
+    fontFallback: options == null ? void 0 : options.fontFallback
+  });
   return new PdfEngine(native, {
     imageConverter: browserImageDataToBlobConverter,
     logger: options == null ? void 0 : options.logger
@@ -6772,13 +7294,15 @@ async function createPdfiumEngine(wasmUrl, options) {
 }
 export {
   BitmapFormat as B,
+  FontFallbackManager as F,
   PdfiumErrorCode as P,
   RenderFlag as R,
   PdfiumNative as a,
   readArrayBuffer as b,
   createPdfiumEngine as c,
   computeFormDrawParams as d,
+  createNodeFontLoader as e,
   isValidCustomKey as i,
   readString as r
 };
-//# sourceMappingURL=direct-engine-DuLFAbiv.js.map
+//# sourceMappingURL=direct-engine-CB3k-o0I.js.map