@ironsoftware/ironpdf 2026.4.1 → 2026.6.1

package/src/public/pdfDocument.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -33,6 +56,11 @@ const io_1 = require("../internal/grpc_layer/pdfium/io");
 const access_1 = require("../internal/access");
 const image_1 = require("../internal/grpc_layer/chrome/image");
 const compress_1 = require("../internal/grpc_layer/pdfium/compress");
+const form_1 = require("../internal/grpc_layer/pdfium/form");
+const path = __importStar(require("path"));
+const linearize_1 = require("../internal/grpc_layer/pdfium/linearize");
+const annotations_1 = require("../internal/grpc_layer/pdfium/annotations");
+const bookmarks_1 = require("../internal/grpc_layer/pdfium/bookmarks");
 const page_1 = require("../internal/grpc_layer/pdfium/page");
 const image_2 = require("../internal/grpc_layer/pdfium/image");
 const jimp_1 = __importDefault(require("jimp"));
@@ -44,6 +72,7 @@ const headerFooter_1 = require("../internal/grpc_layer/pdfium/headerFooter");
 const stamp_1 = require("../internal/grpc_layer/chrome/stamp");
 const BackgroundForeground_1 = require("../internal/grpc_layer/pdfium/BackgroundForeground");
 const security_1 = require("../internal/grpc_layer/pdfium/security");
+const naturalLanguages_1 = require("./naturalLanguages");
 /**
  * Represents a PDF document. Allows: loading, editing, manipulating, merging, signing printing and saving PDFs.
  *
@@ -285,6 +314,298 @@ class PdfDocument {
                 .implement(this.internal_compressAndSaveAs.bind(this))(filePath, imageQuality);
         });
     }
+    /**
+     * Apply the advanced compression pipeline and save the result to a file.
+     *
+     * Combines pdfium-side image DPI downsampling with qpdf-side structural
+     * optimization in a single call.
+     *
+     * @param filePath the file path to save the compressed PDF
+     * @param options  advanced compression options; pass an empty object `{}` to
+     *                 reproduce the legacy compressAndSaveAs behaviour with no
+     *                 image downsampling
+     * @param password the PDF password (empty string if none)
+     */
+    compressAndSaveAsAdvanced(filePath, options, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.internal_compressAndSaveAsAdvanced(filePath, options, password);
+        });
+    }
+    /**
+     * Apply the advanced compression pipeline to byte[] input and save the
+     * compressed result to a file. Returns the compressed bytes as well.
+     */
+    static compressAndSaveAsAdvancedFromBytes(pdfBytes, filePath, options, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!pdfBytes || pdfBytes.length === 0) {
+                throw new Error("pdfBytes must not be null or empty");
+            }
+            if (!options) {
+                throw new Error("options must not be null");
+            }
+            return (0, compress_1.compressAndSaveAsAdvancedFromBytes)(pdfBytes, filePath, options, password !== null && password !== void 0 ? password : "");
+        });
+    }
+    //#endregion
+    //#region form (PDF-2184)
+    /**
+     * Set the document-wide form font for subsequent form-field fills. When
+     * set, the engine skips its automatic Tahoma/Arial fallback embed for
+     * non-ASCII form values and registers the supplied font in the AcroForm
+     * /DR /Font dictionary so default-appearance strings resolve correctly
+     * at render time.
+     *
+     * File-size impact:
+     * - Name-only mode (`fontData` omitted or empty): zero bytes added; the
+     *   font must already be in the document.
+     * - Bytes mode and the font is already embedded with usable glyph data:
+     *   zero bytes added.
+     * - Bytes mode and the font is missing or has no glyph data: the full
+     *   font is embedded.
+     * - Bytes mode with `forceEmbed = true`: a fresh font copy is added
+     *   alongside any existing copy; the document grows on every call.
+     *
+     * @param fontName   PDF font name to register (e.g. "Poppins-Regular").
+     *                   Allowed characters: letters, digits, `_`, `-`, `.`, `+`.
+     * @param fontData   Raw TrueType/OpenType bytes; pass `undefined` or an
+     *                   empty Buffer for name-only mode.
+     * @param forceEmbed When true, embed `fontData` even if a font with the
+     *                   same name and usable glyph data is already present.
+     */
+    setFormFont(fontName, fontData, forceEmbed = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, form_1.setFormFont)(yield this.internal_getId(), fontName, fontData, forceEmbed);
+        });
+    }
+    /**
+     * Load a TrueType/OpenType font from disk and apply it as the
+     * document-wide form font. The PDF font name is derived from the file
+     * name (without extension) when `fontName` is omitted.
+     *
+     * @param fontFilePath Path to a TTF/OTF/TTC font file
+     * @param fontName     Optional PDF font name. When omitted the file name
+     *                     (without extension) is used.
+     * @param forceEmbed   When true, embed even if the font is already present.
+     */
+    setFormFontFromFile(fontFilePath, fontName, forceEmbed = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!fontFilePath) {
+                throw new Error("fontFilePath must not be empty");
+            }
+            const fontData = fs_1.default.readFileSync(fontFilePath);
+            const resolvedName = fontName !== null && fontName !== void 0 ? fontName : deriveFontNameFromPath(fontFilePath);
+            return (0, form_1.setFormFont)(yield this.internal_getId(), resolvedName, fontData, forceEmbed);
+        });
+    }
+    /**
+     * Suppress the automatic Tahoma/Arial fallback embed for non-ASCII form
+     * values without registering any replacement font. Use when zero
+     * file-size growth is required and the template's existing font
+     * references are sufficient for the values being filled.
+     *
+     * Rendering of non-ASCII characters then depends entirely on the
+     * viewer's font substitution.
+     */
+    disableFormFontFallback() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, form_1.disableFormFontFallback)(yield this.internal_getId());
+        });
+    }
+    //#endregion
+    //#region linearize
+    /**
+     * Linearize the current PDF document and return the result as a {@link Buffer} (byte array).
+     * Produces a web-optimized PDF that can be viewed incrementally in a browser.
+     *
+     * @param mode Linearization strategy. Defaults to {@link LinearizationMode.Automatic}.
+     * @returns A Promise resolving to a Buffer containing the linearized PDF bytes.
+     */
+    linearizePdfToBytes(mode = types_1.LinearizationMode.Automatic) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.internal_linearizePdfToBytes(mode);
+        });
+    }
+    /**
+     * Linearize the current PDF document and return the result as a {@link Readable} stream.
+     * Useful for piping directly to file streams or HTTP responses without buffering the
+     * entire PDF in memory.
+     *
+     * <b>Note:</b> Stream output is only supported with {@link LinearizationMode.InMemory}
+     * (or {@link LinearizationMode.Automatic} when memory mode is selected). For
+     * {@link LinearizationMode.FileBased} use {@link linearizePdfToBytes} or
+     * {@link saveAsLinearized}.
+     *
+     * @returns A Promise resolving to a Readable stream of the linearized PDF bytes.
+     */
+    linearizePdfToStream() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.internal_linearizePdfToStream();
+        });
+    }
+    /**
+     * Linearize the current PDF document and save the result to the given output file path.
+     *
+     * @param outputFilePath The file path to save the linearized PDF.
+     * @param mode Linearization strategy. Defaults to {@link LinearizationMode.Automatic}.
+     */
+    saveAsLinearized(outputFilePath, mode = types_1.LinearizationMode.Automatic) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield zod_1.z.function()
+                .args(typeSchema_1.filePathSchema, zod_1.z.nativeEnum(types_1.LinearizationMode).optional())
+                .returns(zod_1.z.promise(zod_1.z.void()))
+                .implement((filePath, m) => __awaiter(this, void 0, void 0, function* () {
+                return this.internal_saveAsLinearized(filePath, m !== null && m !== void 0 ? m : types_1.LinearizationMode.Automatic);
+            }))(outputFilePath, mode);
+        });
+    }
+    /**
+     * Check whether the PDF file at the given path is linearized ("Fast Web View").
+     *
+     * @param pdfFilePath Path to a PDF file on disk.
+     * @param password    Optional password for encrypted PDFs.
+     * @returns A Promise resolving to true if the file is linearized, false otherwise.
+     */
+    static isLinearized(pdfFilePath, password = "") {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield zod_1.z.function()
+                .args(typeSchema_1.pdfFilePathSchema, typeSchema_1.stringSchema.optional())
+                .returns(zod_1.z.promise(typeSchema_1.booleanSchema))
+                .implement((filePath, pwd) => __awaiter(this, void 0, void 0, function* () {
+                const bytes = fs_1.default.readFileSync(filePath);
+                return yield (0, linearize_1.isLinearizedFromBytes)(bytes, pwd !== null && pwd !== void 0 ? pwd : "");
+            }))(pdfFilePath, password);
+        });
+    }
+    /**
+     * Linearize the given PDF bytes and return the linearized bytes.
+     * Static helper for linearizing PDFs without creating a PdfDocument instance.
+     *
+     * @param pdfBytes Buffer containing the PDF data.
+     * @param password Optional password to decrypt the PDF if encrypted.
+     * @param mode     Linearization strategy. Defaults to {@link LinearizationMode.Automatic}.
+     */
+    static linearizePdfBytesToBytes(pdfBytes, password = "", mode = types_1.LinearizationMode.Automatic) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield zod_1.z.function()
+                .args(typeSchema_1.bufferSchema, typeSchema_1.stringSchema.optional(), zod_1.z.nativeEnum(types_1.LinearizationMode).optional())
+                .returns(zod_1.z.promise(zod_1.z.instanceof(buffer_1.Buffer)))
+                .implement((bytes, pwd, m) => __awaiter(this, void 0, void 0, function* () {
+                return yield (0, linearize_1.linearizeCoreFromBytes)(bytes, pwd !== null && pwd !== void 0 ? pwd : "", m !== null && m !== void 0 ? m : types_1.LinearizationMode.Automatic);
+            }))(pdfBytes, password, mode);
+        });
+    }
+    /**
+     * Linearize the given PDF bytes and save the result to the given output file path.
+     * Static helper for linearizing PDFs without creating a PdfDocument instance.
+     *
+     * @param pdfBytes       Buffer containing the PDF data.
+     * @param outputFilePath The file path to save the linearized PDF.
+     * @param password       Optional password to decrypt the PDF if encrypted.
+     * @param mode           Linearization strategy. Defaults to {@link LinearizationMode.Automatic}.
+     */
+    static saveAsLinearizedFromBytes(pdfBytes, outputFilePath, password = "", mode = types_1.LinearizationMode.Automatic) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield zod_1.z.function()
+                .args(typeSchema_1.bufferSchema, typeSchema_1.filePathSchema, typeSchema_1.stringSchema.optional(), zod_1.z.nativeEnum(types_1.LinearizationMode).optional())
+                .returns(zod_1.z.promise(zod_1.z.void()))
+                .implement((bytes, filePath, pwd, m) => __awaiter(this, void 0, void 0, function* () {
+                const linearized = yield (0, linearize_1.linearizeCoreFromBytes)(bytes, pwd !== null && pwd !== void 0 ? pwd : "", m !== null && m !== void 0 ? m : types_1.LinearizationMode.Automatic);
+                fs_1.default.writeFileSync(filePath, linearized);
+            }))(pdfBytes, outputFilePath, password, mode);
+        });
+    }
+    //#endregion
+    //#region elementLocations
+    /**
+     * Retrieves the rendered page locations of HTML elements that were tracked during rendering.
+     *
+     * To use this feature, set {@link ChromePdfRenderOptions.elementQuerySelectors} with CSS
+     * selectors before rendering. After rendering, call this method to retrieve the page index
+     * and coordinates of each matched element.
+     *
+     * Results are cached on first call and reused on subsequent calls. If you modify the
+     * document's annotations after rendering, call {@link resetElementLocationCache} to force
+     * the cache to be rebuilt on next access.
+     *
+     * Mirrors {@code IronPdf.PdfDocument.GetElementLocations()} on the C# side.
+     *
+     * @returns A list of {@link RenderedElementLocation} objects, one per matched element,
+     * sorted in document order. Returns an empty list if no element query selectors were
+     * configured or no elements matched.
+     */
+    getElementLocations() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.internal_getElementLocations();
+        });
+    }
+    /**
+     * Clears the cached result of {@link getElementLocations}, forcing a fresh scan of the
+     * document's annotations on the next call. Call this if you've modified the document's
+     * annotations or structure after rendering.
+     */
+    resetElementLocationCache() {
+        this.cachedElementLocations = null;
+    }
+    //#endregion
+    //#region bookmarks
+    /**
+     * Retrieves all outline bookmarks (table-of-contents entries) in this PDF document.
+     *
+     * <p>Bookmarks are returned as a flat list with parent linkage via
+     * {@link Bookmark.parentItemId}. Roots have an empty {@code parentItemId}.
+     * Use {@link Bookmark.hierarchy} for depth information.</p>
+     *
+     * <p>Auto-bookmarks generated from HTML headings (via
+     * {@link ChromePdfRenderOptions.autoBookmarksFromHeadings}) are included.</p>
+     *
+     * <p>Mirrors {@code IronPdf.PdfDocument.Bookmarks} on the C# side.</p>
+     *
+     * @returns A list of {@link Bookmark} objects, sorted in document order.
+     *          Returns an empty list if the document has no bookmarks.
+     */
+    getBookmarks() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.internal_getBookmarks();
+        });
+    }
+    //#endregion
+    //#region annotation
+    /**
+     * Adds a clickable internal hyperlink annotation that navigates to another page within
+     * the same PDF document. Useful for building custom tables of contents, cross-references,
+     * and in-document navigation.
+     *
+     * The target page and display options are configured via the {@link LinkAnnotation}
+     * fields ({@code destinationPageIndex}, {@code destinationType}, etc.).
+     *
+     * Mirrors {@code IronPdf.Annotations.LinkAnnotation} on the C# side.
+     *
+     * @example
+     * ```ts
+     * await pdf.addLinkAnnotation({
+     *     pageIndex: 0,
+     *     destinationPageIndex: 3,
+     *     x: 72, y: 700,
+     *     width: 300, height: 18,
+     *     contents: "Chapter 1",
+     * });
+     * ```
+     */
+    addLinkAnnotation(link) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.internal_addLinkAnnotation(link);
+        });
+    }
+    /**
+     * Retrieves the number of annotations contained on the specified page.
+     *
+     * @param pageIndex Zero-based page index. The first page has a page index of 0.
+     */
+    getAnnotationCount(pageIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.internal_getAnnotationCount(pageIndex);
+        });
+    }
     //#endregion
     //#region page
     /**
@@ -485,23 +806,20 @@ class PdfDocument {
                 .implement(this.internal_convertToPdfA.bind(this))(pdfaVersion, customICC);
         });
     }
-    // TODO: Re-enable once IronPdfEngine handler for Pdfium_ConvertToPdfUAForScreenReader
-    // is fixed to call HtmlHelper.HtmlStructTreeDOM() and ConvertToPdfUAForScreenReader().
-    // Currently the engine handler ignores the HTML and falls back to basic ConvertToPdfUA,
-    // producing a flat tag tree instead of proper semantic structure.
-    // See: IronPdfServiceHandler.cs:97-108
-    //
-    // public static async fromHtmlAsPdfUA(
-    // 	html: string,
-    // 	naturalLanguages: NaturalLanguages = NaturalLanguages.English,
-    // 	options?: {
-    // 		renderOptions?: ChromePdfRenderOptions | undefined;
-    // 	} | undefined
-    // ): Promise<PdfDocument> {
-    // 	const pdf = await PdfDocument.fromHtml(html, options);
-    // 	await toPdfUAForScreenReader(await pdf.internal_getId(), html, naturalLanguages);
-    // 	return pdf;
-    // }
+    /**
+     * Render HTML to PDF and convert to PDF/UA format with screen reader support.
+     * Produces a proper semantic structure tree (Sect → H1, P, etc.) for accessibility.
+     * @param html The HTML string to render
+     * @param naturalLanguages Document language for screen readers (default: English)
+     * @param options Optional render options
+     */
+    static fromHtmlAsPdfUA(html, naturalLanguages = naturalLanguages_1.NaturalLanguages.English, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pdf = yield PdfDocument.fromHtml(html, options);
+            yield (0, pdfa_1.toPdfUAForScreenReader)(yield pdf.internal_getId(), html, naturalLanguages);
+            return pdf;
+        });
+    }
     /**
      * Convert the current document into the specified PDF/UA standard format
      */
@@ -852,6 +1170,15 @@ class PdfDocument {
      */
     constructor(pdfInput, password, trackChanges) {
         var _a;
+        /**
+         * Cache for {@link getElementLocations}. Built lazily on first call.
+         *
+         * The underlying element-query anchor annotations are written during rendering and are
+         * not expected to be mutated afterwards, so a simple populate-once cache is appropriate.
+         * Callers who modify the document's annotations after rendering should call
+         * {@link resetElementLocationCache} to force a rebuild.
+         */
+        this.cachedElementLocations = null;
         if (pdfInput) {
             this.pdfDocumentId = undefined;
             const input = (0, util_1.separatePdfInput)(pdfInput);
@@ -1163,6 +1490,133 @@ class PdfDocument {
             return yield (0, compress_1.compressAndSaveAs)(yield this.internal_getId(), filePath, imageQuality);
         });
     }
+    internal_compressAndSaveAsAdvanced(filePath, options, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!filePath || filePath.trim().length === 0) {
+                throw new Error("filePath must not be empty");
+            }
+            if (!options) {
+                throw new Error("options must not be null");
+            }
+            if (options.jpegQuality !== undefined &&
+                options.jpegQuality !== null &&
+                (options.jpegQuality < 1 || options.jpegQuality > 100)) {
+                throw new Error(`Invalid jpegQuality (${options.jpegQuality}). Must be between 1 and 100.`);
+            }
+            return yield (0, compress_1.compressAndSaveAsAdvanced)(yield this.internal_getId(), filePath, options, password !== null && password !== void 0 ? password : "");
+        });
+    }
+    //#endregion
+    //#region linearize
+    /**
+     * Linearize the current PDF document and return the result as a Buffer.
+     */
+    internal_linearizePdfToBytes(mode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = yield this.internal_getId();
+            return yield (0, linearize_1.linearizeCoreFromId)(id, () => this.internal_saveAsBuffer(), "", mode);
+        });
+    }
+    /**
+     * Linearize the current PDF document and return the result as a Readable stream.
+     * Always uses the in-memory streaming RPC.
+     */
+    internal_linearizePdfToStream() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, linearize_1.linearizeInMemoryFromIdStream)(yield this.internal_getId());
+        });
+    }
+    /**
+     * Linearize the current PDF document and save the result to the given output file path.
+     */
+    internal_saveAsLinearized(outputFilePath, mode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = yield this.internal_getId();
+            const linearized = yield (0, linearize_1.linearizeCoreFromId)(id, () => this.internal_saveAsBuffer(), "", mode);
+            fs_1.default.writeFileSync(outputFilePath, linearized);
+        });
+    }
+    internal_getElementLocations() {
+        var _a, _b, _c, _d, _e;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.cachedElementLocations !== null) {
+                return this.cachedElementLocations;
+            }
+            const id = yield this.internal_getId();
+            const pageInfos = yield (0, page_1.getPageInfo)(id);
+            const locations = [];
+            for (let pageIdx = 0; pageIdx < pageInfos.length; pageIdx++) {
+                const annotations = yield (0, annotations_1.getAnnotations)(id, pageIdx);
+                for (const wrapped of annotations) {
+                    if (!wrapped.link)
+                        continue;
+                    const dest = wrapped.link.dest;
+                    if (!dest || !dest.startsWith(PdfDocument.ELEMENT_QUERY_PREFIX))
+                        continue;
+                    const remainder = dest.substring(PdfDocument.ELEMENT_QUERY_PREFIX.length);
+                    const dashIdx = remainder.indexOf("-");
+                    if (dashIdx <= 0)
+                        continue;
+                    const indexStr = remainder.substring(0, dashIdx);
+                    const elementIndex = parseInt(indexStr, 10);
+                    if (isNaN(elementIndex))
+                        continue;
+                    const encodedText = remainder.substring(dashIdx + 1);
+                    let text;
+                    try {
+                        text = decodeURIComponent(encodedText);
+                    }
+                    catch (_f) {
+                        text = encodedText;
+                    }
+                    const innerRect = (_a = wrapped.link.annotation) === null || _a === void 0 ? void 0 : _a.rectangle;
+                    const rectangle = innerRect
+                        ? {
+                            x: (_b = innerRect.x) !== null && _b !== void 0 ? _b : 0,
+                            y: (_c = innerRect.y) !== null && _c !== void 0 ? _c : 0,
+                            width: (_d = innerRect.width) !== null && _d !== void 0 ? _d : 0,
+                            height: (_e = innerRect.height) !== null && _e !== void 0 ? _e : 0,
+                        }
+                        : { x: 0, y: 0, width: 0, height: 0 };
+                    locations.push({ text, pageIndex: pageIdx, rectangle, elementIndex });
+                }
+            }
+            locations.sort((a, b) => a.elementIndex - b.elementIndex);
+            this.cachedElementLocations = locations;
+            return this.cachedElementLocations;
+        });
+    }
+    //#endregion
+    //#region annotation
+    internal_addLinkAnnotation(link) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!link) {
+                throw new Error("link annotation cannot be null or undefined");
+            }
+            if (link.pageIndex < 0) {
+                throw new Error("Invalid page index when adding link annotation");
+            }
+            if (link.destinationPageIndex < 0) {
+                throw new Error("Invalid destination page index when adding link annotation");
+            }
+            yield (0, annotations_1.addLinkAnnotation)(yield this.internal_getId(), link);
+        });
+    }
+    internal_getAnnotationCount(pageIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (pageIndex < 0) {
+                throw new Error("Invalid page index when getting annotation count");
+            }
+            return yield (0, annotations_1.getAnnotationCount)(yield this.internal_getId(), pageIndex);
+        });
+    }
+    //#endregion
+    //#region bookmarks
+    internal_getBookmarks() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, bookmarks_1.getBookmarks)(yield this.internal_getId());
+        });
+    }
     //#endregion
     //#region page
     /**
@@ -1649,4 +2103,22 @@ class PdfDocument {
     }
 }
 exports.PdfDocument = PdfDocument;
+//#endregion
+//#region elementLocations
+/**
+ * Prefix used by the engine-side element query JavaScript extension when injecting anchor
+ * markers. Must match {@code IronPdf.TableOfContents.ElementQueryJavascriptExtension.ELEMENT_QUERY_PREFIX}
+ * on the C# side.
+ */
+PdfDocument.ELEMENT_QUERY_PREFIX = "ironpdf-elq-";
+/**
+ * Derive a PDF font name from a font file path: strip the directory and the
+ * extension. Used by {@link PdfDocument.setFormFontFromFile} when no
+ * explicit name is supplied.
+ */
+function deriveFontNameFromPath(fontFilePath) {
+    const base = path.basename(fontFilePath);
+    const dot = base.lastIndexOf(".");
+    return dot > 0 ? base.substring(0, dot) : base;
+}
 //# sourceMappingURL=pdfDocument.js.map