@ironsoftware/ironpdf
Version:
IronPDF for Node
1,045 lines • 94.9 kB
JavaScript
"use strict";
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) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.PdfDocument = void 0;
const buffer_1 = require("buffer");
const types_1 = require("./types");
const typeSchema_1 = require("../internal/zod/typeSchema");
const zod_1 = require("zod");
const securitySchema_1 = require("../internal/zod/securitySchema");
const pdfDocumentSchema_1 = require("../internal/zod/pdfDocumentSchema");
const stampSchema_1 = require("../internal/zod/stampSchema");
const affixSchema_1 = require("../internal/zod/affixSchema");
const signatureSchema_1 = require("../internal/zod/signatureSchema");
const imageSchema_1 = require("../internal/zod/imageSchema");
const paperSchema_1 = require("../internal/zod/paperSchema");
const pageSchema_1 = require("../internal/zod/pageSchema");
const renderSchema_1 = require("../internal/zod/renderSchema");
const util_1 = require("../internal/grpc_layer/util");
const fs_1 = __importDefault(require("fs"));
const render_1 = require("../internal/grpc_layer/chrome/render");
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 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"));
const text_1 = require("../internal/grpc_layer/pdfium/text");
const pdfa_1 = require("../internal/grpc_layer/pdfium/pdfa");
const metadata_1 = require("../internal/grpc_layer/pdfium/metadata");
const signing_1 = require("../internal/grpc_layer/pdfium/signing");
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.
*
* @remark Make sure that you call {@link PdfDocument.close} or {@link cleanUp} to free the memory, when you stop using the PdfDocument object.
*/
class PdfDocument {
//#region io
/**
* Open or Create a PdfDocument from a {@link PdfInput}
* @param pdfInput {@link PdfInput}
* @param options including {@link PdfPassword} {@link ChromePdfRenderOptions} {@link HttpLoginCredentials} mainHtmlFile
*/
static open(pdfInput, options) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(typeSchema_1.pdfInputSchema, zod_1.z.object({
password: typeSchema_1.pdfPasswordSchema.optional(),
renderOptions: renderSchema_1.chromePdfRenderOptionsSchema.optional(),
httpLoginCredentials: renderSchema_1.httpLoginCredentialsSchema.optional(),
mainHtmlFile: typeSchema_1.stringSchema.optional(),
trackChanges: typeSchema_1.changeTrackingModesSchema.optional(),
}).optional())
.returns(zod_1.z.promise(pdfDocumentSchema_1.pdfDocumentSchema))
.implement(this.internal_open.bind(this))(pdfInput, options);
});
}
/**
* Open a PdfDocument from .pdf file
* @param pdfFilePath A path to .pdf file
* @param Optionally track changes to the document (for use with incremental saves)
*/
static fromFile(pdfFilePath, trackChanges) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(typeSchema_1.pdfFilePathSchema, typeSchema_1.changeTrackingModesSchema.optional())
.returns(zod_1.z.promise(pdfDocumentSchema_1.pdfDocumentSchema))
.implement(this.internal_fromFile.bind(this))(pdfFilePath, trackChanges);
});
}
/**
* Create a PdfDocument from an Url
* @param url A website Url
* @param options including {@link ChromePdfRenderOptions}
*/
static fromUrl(url, options) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(zod_1.z.union([typeSchema_1.urlSchema, typeSchema_1.stringSchema]), zod_1.z.object({
renderOptions: renderSchema_1.chromePdfRenderOptionsSchema.optional(),
}).optional())
.returns(zod_1.z.promise(pdfDocumentSchema_1.pdfDocumentSchema))
.implement(this.internal_fromUrl.bind(this))(url, options);
});
}
/**
* Creates a PDF file from a local Zip file, and returns it as a {@link PdfDocument}.
* IronPDF is a W3C standards compliant HTML rendering based on Google's Chromium browser.
* If your output PDF does not look as expected:
*
* - Validate your HTML file using https://validator.w3.org/ & CSS https://jigsaw.w3.org/css-validator/
*
* - To debug HTML, view the file in Chrome web browser's print preview which will work almost exactly as IronPDF.
*
* - Read our detailed documentation on pixel perfect HTML to PDF: https://ironpdf.com/tutorials/pixel-perfect-html-to-pdf/
*
* @param zipFilePath Path to a Zip to be rendered as a PDF.
* @param options including {@link ChromePdfRenderOptions} and `mainHtmlFile` a main .html file default: `index.html`
*/
static fromZip(zipFilePath, options) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(typeSchema_1.stringSchema, zod_1.z.object({
renderOptions: renderSchema_1.chromePdfRenderOptionsSchema.optional(),
mainHtmlFile: typeSchema_1.stringSchema.optional()
}).optional())
.returns(zod_1.z.promise(pdfDocumentSchema_1.pdfDocumentSchema))
.implement(this.internal_fromZip.bind(this))(zipFilePath, options);
});
}
/**
* Creates a PDF file from a Html string, and returns it as an {@link PdfDocument} object which can be edited and saved to disk or served on a website.
*
* ------------------------------------------------
*
* **Usage:**
* ```ts
* const pdf = await fromHtml(htmlStringOrHtmlFilePath, renderOptions);
* ```
*
* ------------------------------------------------
*
* @param htmlStringOrHtmlFilePath The Html to be rendered as a PDF.
* @param options including {@link ChromePdfRenderOptions}
* @returns A `PdfDocument` generated from the provided HTML file.
*
* ---
* ### Important Notes:
*
* 🐳 **Docker Limitation:**
* This method **does not work** for **HTML file path** when the application runs inside a Docker environment
* due to rendering engine restrictions.
* In such cases, use `fromZip()` instead.
*
* 📄 **Input:** Requires access to a local HTML file on disk if htmlFilePath is passing.
*
* ---
* ### Related Methods:
* 📌 `fromZip()` — Recommended alternative for rendering from HTML file when running inside Docker.
*/
static fromHtml(htmlStringOrHtmlFilePath, options) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(typeSchema_1.stringSchema, zod_1.z.object({
renderOptions: renderSchema_1.chromePdfRenderOptionsSchema.optional(),
}).optional())
.returns(zod_1.z.promise(pdfDocumentSchema_1.pdfDocumentSchema))
.implement(this.internal_fromHtml.bind(this))(htmlStringOrHtmlFilePath, options);
});
}
/**
* Converts multiple image files to a PDF document. Each image creates 1 page which matches the image
* dimensions. The default PaperSize is A4. You can set it via ImageToPdfConverter.PaperSize.
* Note: Imaging.ImageBehavior.CropPage will set PaperSize equal to ImageSize.
* @param images The image file path name(s) or {@link ImageBuffer} object(s)
* @param options including {@link ImageToPdfOptions}
*/
static fromImage(images, options) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(zod_1.z.union([typeSchema_1.imageFilePathSchema, zod_1.z.array(typeSchema_1.imageFilePathSchema), typeSchema_1.imageBufferSchema, zod_1.z.array(typeSchema_1.imageBufferSchema)]), zod_1.z.object({
imageToPdfOptions: imageSchema_1.imageToPdfOptionsSchema.optional(),
}).optional())
.returns(zod_1.z.promise(pdfDocumentSchema_1.pdfDocumentSchema))
.implement(this.internal_fromImage.bind(this))(images, options);
});
}
/**
* Static method that joins (concatenates) multiple PDF documents together into one compiled PDF document.
* If the PDF contains form fields the form field in the resulting PDF's name will be appended with '_{index}' e.g. 'Name' will be 'Name_0'
* @param pdfs array of PDF
*/
static mergePdf(pdfs) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(zod_1.z.array(typeSchema_1.pdfInputSchema))
.returns(zod_1.z.promise(pdfDocumentSchema_1.pdfDocumentSchema))
.implement(this.internal_mergePdf.bind(this))(pdfs);
});
}
/**
* Saves the PdfDocument to a file.
* @param filePath Target file path
* @param saveOptions see {@link SaveOptions}
*/
saveAs(filePath, saveOptions) {
return zod_1.z.function()
.args(typeSchema_1.stringSchema, typeSchema_1.saveOptionsSchema.optional())
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_saveAs.bind(this))(filePath, saveOptions);
}
/**
* Saves the PdfDocument to a binary (Buffer)
* @param saveOptions see {@link SaveOptions}
*/
saveAsBuffer(saveOptions) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(typeSchema_1.saveOptionsSchema.optional())
.returns(zod_1.z.promise(typeSchema_1.bufferSchema))
.implement(this.internal_saveAsBuffer.bind(this))(saveOptions);
});
}
//#endregion
//#region compress
/**
* Compress existing PDF images using JPG encoding and the specified settings.
* @deprecated Use {@link compressAndSaveAs}, {@link compressPdfToBytes}, or {@link compressPdfToStream} instead for better compression results.
* @param imageQuality Quality (1 - 100) to use during compression
* @param scaleToVisibleSize Scale down the image resolution according to its visible size in the PDF document
*/
compressSize(imageQuality, scaleToVisibleSize = false) {
return __awaiter(this, void 0, void 0, function* () {
return yield zod_1.z.function()
.args(typeSchema_1.numberSchema, typeSchema_1.booleanSchema.optional())
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_compressSize.bind(this))(imageQuality, scaleToVisibleSize);
});
}
/**
* Remove document struct tree information which describes the logical layout of the document.
* Removing the "structure tree" can significantly reduce the disk space used by the document.
* Removing the "structure tree" of a complicated document can negatively impact text selection.
*/
compressStructTree() {
return __awaiter(this, void 0, void 0, function* () {
return this.internal_compressStructTree();
});
}
/**
* Compress the PDF and return the result as a Buffer (byte array).
* Uses QPdf compression which can significantly reduce file size.
* @param imageQuality Optional JPEG quality (1-100) for image compression. If omitted, default compression is applied.
* @returns A Promise resolving to a Buffer containing the compressed PDF bytes.
*/
compressPdfToBytes(imageQuality) {
return __awaiter(this, void 0, void 0, function* () {
return yield zod_1.z.function()
.args(typeSchema_1.numberSchema.optional())
.returns(zod_1.z.promise(zod_1.z.instanceof(buffer_1.Buffer)))
.implement(this.internal_compressPdfToBytes.bind(this))(imageQuality);
});
}
/**
* Compress the PDF and return the result as a Readable stream.
* Uses QPdf compression which can significantly reduce file size.
* Useful for piping directly to file streams or HTTP responses without buffering the entire PDF in memory.
* @param imageQuality Optional JPEG quality (1-100) for image compression. If omitted, default compression is applied.
* @returns A Promise resolving to a Readable stream of the compressed PDF bytes.
*/
compressPdfToStream(imageQuality) {
return __awaiter(this, void 0, void 0, function* () {
return yield zod_1.z.function()
.args(typeSchema_1.numberSchema.optional())
.returns(zod_1.z.promise(zod_1.z.any()))
.implement(this.internal_compressPdfToStream.bind(this))(imageQuality);
});
}
/**
* Compress the PDF and save the result directly to a file.
* Uses QPdf compression which can significantly reduce file size.
* @param filePath The output file path to save the compressed PDF.
* @param imageQuality Optional JPEG quality (1-100) for image compression. If omitted, default compression is applied.
*/
compressAndSaveAs(filePath, imageQuality) {
return __awaiter(this, void 0, void 0, function* () {
return yield zod_1.z.function()
.args(typeSchema_1.stringSchema, typeSchema_1.numberSchema.optional())
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_compressAndSaveAs.bind(this))(filePath, imageQuality);
});
}
//#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
/**
* Gets information of all pages in the PdfDocument
*/
getPagesInfo() {
return __awaiter(this, void 0, void 0, function* () {
return this.internal_getPagesInfo();
});
}
/**
* Gets the number of pages in the PdfDocument.
*/
getPageCount() {
return __awaiter(this, void 0, void 0, function* () {
return this.internal_getPageCount();
});
}
/**
* Set the page orientation.
* @param pageRotation see {@link PageRotation}
* @param options including {@link PdfPageSelection}
*/
setRotation(pageRotation, options) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(pageSchema_1.pageRotationSchema, zod_1.z.object({ pdfPageSelection: typeSchema_1.pdfPageSelectionSchema.optional() }).optional())
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_setRotation.bind(this))(pageRotation, options);
});
}
/**
* Resize a page to the specified dimensions
* @param newSize {@link PdfPaperSize}
* @param options including {@link PdfPageSelection}
*/
resize(newSize, options) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(paperSchema_1.pdfPaperSizeSchema, zod_1.z.object({ pdfPageSelection: typeSchema_1.pdfPageSelectionSchema.optional() }).optional())
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_resize.bind(this))(newSize, options);
});
}
/**
* Adds another PDF to the beginning of the current PdfDocument
* If AnotherPdfFile contains form fields, those fields will be appended with '_' in the resulting PDF. e.g. 'Name' will be 'Name_'
* @param fromPdfDocument PdfDocument to prepend
*/
prependAnotherPdf(fromPdfDocument) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(pdfDocumentSchema_1.pdfDocumentSchema)
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_prependAnotherPdf.bind(this))(fromPdfDocument);
});
}
/**
* Appends another PDF to the end of the current <see cref="PdfDocument"/>
* If AnotherPdfFile contains form fields, those fields will be appended with '_' in the resulting PDF. e.g. 'Name' will be 'Name_'
* @param fromPdfDocument PdfDocument to Append
*/
appendAnotherPdf(fromPdfDocument) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(pdfDocumentSchema_1.pdfDocumentSchema)
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_appendAnotherPdf.bind(this))(fromPdfDocument);
});
}
/**
* Inserts another PDF into the current PdfDocument, starting at a given Page Index.
* If AnotherPdfFile contains form fields, those fields will be appended with '_' in the resulting PDF. e.g. 'Name' will be 'Name_'
* @param fromPdfDocument Another PdfDocument
* @param insertAtPageIndex Index at which to insert the new content. Note: Page 1 has index 0...
*/
insertPagesFromAnotherPdf(fromPdfDocument, insertAtPageIndex) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(pdfDocumentSchema_1.pdfDocumentSchema, typeSchema_1.numberSchema.describe("insertAtPageIndex: number"))
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_insertPagesFromAnotherPdf.bind(this))(fromPdfDocument, insertAtPageIndex);
});
}
/**
* Removes a range of pages from the PDF
* @param pages pages to remove
*/
removePage(pages) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(typeSchema_1.pdfPageSelectionSchema)
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_removePage.bind(this))(pages);
});
}
/**
* Creates a new PDF by copying a range of pages from this {@link PdfDocument}.
* @param pages pages to copy (default "all")
*/
duplicate(pages = "all") {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(typeSchema_1.pdfPageSelectionSchema)
.returns(zod_1.z.promise(pdfDocumentSchema_1.pdfDocumentSchema))
.implement(this.internal_duplicate.bind(this))(pages);
});
}
//#endregion
//#region image
/**
* Finds all embedded Images from within a specified pages in the PDF and returns them as Buffer
* @param options including {@link PdfPageSelection}
*/
extractRawImages(options) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(zod_1.z.object({ fromPages: typeSchema_1.pdfPageSelectionSchema.optional() }).optional())
.returns(zod_1.z.promise(typeSchema_1.bufferArraySchema))
.implement(this.internal_extractRawImages.bind(this))(options);
});
}
/**
* Renders the PDF and exports image Files in convenient formats. 1 image file is created for each
* page.
*
* @param options including {@link PdfPageSelection} {@link ImageType}
*
* @return array of images as Buffer[]
*/
rasterizeToImageBuffers(options) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(zod_1.z.object({
fromPages: typeSchema_1.pdfPageSelectionSchema.optional(),
imageType: imageSchema_1.imageTypeSchema.optional()
}).optional())
.returns(zod_1.z.promise(typeSchema_1.bufferArraySchema))
.implement(this.internal_rasterizeToImageBuffers.bind(this))(options);
});
}
/**
* Renders the PDF and exports image Files in convenient formats. 1 image file is created for each
* page. Running number will append output file path.
*
* @param filePath output file path.
* @param options including {@link PdfPageSelection} {@link ImageType}
*
* @return array of images file name as string[]
*/
rasterizeToImageFiles(filePath, options) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(typeSchema_1.filePathSchema, zod_1.z.object({
fromPages: typeSchema_1.pdfPageSelectionSchema.optional(),
type: imageSchema_1.imageTypeSchema.optional()
}).optional())
.returns(zod_1.z.promise(typeSchema_1.stringArraySchema))
.implement(this.internal_rasterizeToImageFiles.bind(this))(filePath, options);
});
}
//#endregion
//#region text
/**
* Replace the specified old text with new text on a given page
* @param oldText Old text to remove
* @param newText New text to add
* @param onPages Page index to search for old text to replace (default "all")
*/
replaceText(oldText, newText, onPages) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(zod_1.z.string({ description: "oldText: string" }), zod_1.z.string({ description: "newText: string" }), typeSchema_1.pdfPageSelectionSchema.optional())
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_replaceText.bind(this))(oldText, newText, onPages);
});
}
extractText(onPages) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(typeSchema_1.pdfPageSelectionSchema.optional())
.returns(zod_1.z.promise(zod_1.z.string()))
.implement(this.internal_extractText.bind(this))(onPages);
});
}
//#endregion
//#region pdfA
/**
* Convert the current document into the specified PDF-A standard format
* @param pdfaVersion The PDF/A version to convert to (default: PdfA3b)
* @param customICC (Optional) Custom color profile file path
*/
convertToPdfA(pdfaVersion = pdfa_1.PdfAVersions.PdfA3b, customICC) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(zod_1.z.nativeEnum(pdfa_1.PdfAVersions, { description: "pdfaVersion: PdfAVersions" }), zod_1.z.string({ description: "customICC: string" }).optional())
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_convertToPdfA.bind(this))(pdfaVersion, customICC);
});
}
/**
* 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
*/
convertToPdfUA(naturalLanguages, pdfUaVersion = pdfa_1.PdfUAVersions.PdfUA1) {
return __awaiter(this, void 0, void 0, function* () {
return this.internal_convertToPdfUA(naturalLanguages, pdfUaVersion);
});
}
//#endregion
//#region metadata
/**
* Gets a Map<string, string> of metadata properties
*/
getMetadata() {
return __awaiter(this, void 0, void 0, function* () {
return this.internal_getMetadata();
});
}
/**
* Add or Update a single metadata property
* @param key
* @param value
*/
addOrUpdateMetadata(key, value) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(zod_1.z.string({ description: "key: string" }), zod_1.z.string({ description: "value: string" }))
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_addOrUpdateMetadata.bind(this))(key, value);
});
}
/**
* Remove a single metadata property
* @param key
*/
removeMetadata(key) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(zod_1.z.string({ description: "key: string" }))
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_removeMetadata.bind(this))(key);
});
}
/**
* Sets a whole metadata properties Map<string, string> (override all the metadata property)
* @param newMetadataDictionary new metadata properties Map<string, string>
*/
overrideMetadata(newMetadataDictionary) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(typeSchema_1.mapStringSchema)
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_overrideMetadata.bind(this))(newMetadataDictionary);
});
}
//#endregion
//#region signing
/**
* Sign PDF with digital signature certificate.
* Note that the PDF will not be fully signed until Saved
* using {@link saveAs} or {@link saveAsBuffer}
*
* Multiple certificates may be used.
* @param signature see {@link DigitalSignature}
*/
signDigitalSignature(signature) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(signatureSchema_1.digitalSignatureSchema)
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_signDigitalSignature.bind(this))(signature);
});
}
/**
* Check if PdfDocument was signed or not
*/
isSigned() {
return __awaiter(this, void 0, void 0, function* () {
return this.internal_isSigned();
});
}
/**
* Count the number signature that signed to this PdfDocument
*/
signatureCount() {
return __awaiter(this, void 0, void 0, function* () {
return this.internal_signatureCount();
});
}
/**
* Get all verified digital signatures from this PdfDocument.
* Returns details including signature name, signer contact, reason, location, date, and validity.
* @returns A Promise resolving to an array of {@link VerifiedSignature} objects.
*/
getVerifiedSignatures() {
return __awaiter(this, void 0, void 0, function* () {
return this.internal_getVerifiedSignatures();
});
}
//#endregion
//#region header/footer (affix)
/**
* Apply page header on top of an existing Pdf.
* @param header {@link TextAffix}
* @param toPages {@link PdfPageSelection}
*/
addTextHeader(header, toPages) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(affixSchema_1.textAffixSchema, typeSchema_1.pdfPageSelectionSchema.optional())
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_addTextHeader.bind(this))(header, toPages);
});
}
/**
* Apply page footer on top of an existing Pdf.
* @param footer {@link TextAffix}
* @param toPages {@link PdfPageSelection}
*/
addTextFooter(footer, toPages) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(affixSchema_1.textAffixSchema, typeSchema_1.pdfPageSelectionSchema.optional())
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_addTextFooter.bind(this))(footer, toPages);
});
}
/**
* Apply HTML header on top of an existing Pdf.
* @param header {@link HtmlAffix}
* @param toPages {@link PdfPageSelection}
*/
addHtmlHeader(header, toPages) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(affixSchema_1.htmlAffixSchema, typeSchema_1.pdfPageSelectionSchema.optional())
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_addHtmlHeader.bind(this))(header, toPages);
});
}
/**
* Apply HTML footer on top of an existing Pdf.
* @param footer {@link HtmlAffix}
* @param toPages {@link PdfPageSelection}
*/
addHtmlFooter(footer, toPages) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(affixSchema_1.htmlAffixSchema, typeSchema_1.pdfPageSelectionSchema.optional())
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_addHtmlFooter.bind(this))(footer, toPages);
});
}
//#endregion
//#region stamp
/**
* Edits the PDF by applying the HTML's rendered to only selected page(s).
* @param htmlStringOrHtmlFilePath
* @param options including {@link HtmlStampOptions} {@link PdfPageSelection}
*/
stampHtml(htmlStringOrHtmlFilePath, options) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(zod_1.z.union([typeSchema_1.htmlFilePathSchema, typeSchema_1.htmlStringSchema]), zod_1.z.object({
htmlStampOptions: stampSchema_1.htmlStampOptionsSchema.optional(),
toPages: typeSchema_1.pdfPageSelectionSchema.optional()
}).optional())
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_stampHtml.bind(this))(htmlStringOrHtmlFilePath, options);
});
}
/**
* Edits the PDF by applying the image to only selected page(s).
* @param image image file path or image buffer
* @param options including {@link ImageStampOptions} {@link PdfPageSelection}
*/
stampImage(image, options) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(zod_1.z.union([typeSchema_1.imageFilePathSchema, typeSchema_1.imageBufferSchema]), zod_1.z.object({
imageStampOptions: stampSchema_1.imageStampOptionsSchema.optional(),
toPages: typeSchema_1.pdfPageSelectionSchema.optional()
}).optional())
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_stampImage.bind(this))(image, options);
});
}
/**
* Edits the PDF by applying the text to only selected page(s).
* @param text text to stamp
* @param options including {@link TextStampOptions} {@link PdfPageSelection}
*/
stampText(text, options) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(typeSchema_1.stringSchema, zod_1.z.object({
textStampOptions: stampSchema_1.textStampOptionsSchema.optional(),
toPages: typeSchema_1.pdfPageSelectionSchema.optional()
}).optional())
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_stampText.bind(this))(text, options);
});
}
/**
* Edits the PDF by applying the barcode to only selected page(s).
* @param barcodeValue barcode
* @param options including {@link BarcodeType} {@link BarcodeStampOptions} {@link PdfPageSelection}
*/
stampBarcode(barcodeValue, options) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(typeSchema_1.stringSchema, zod_1.z.object({
barcodeEncoding: typeSchema_1.barcodeTypeSchema,
barcodeStampOptions: stampSchema_1.barcodeStampOptionsSchema.optional(),
toPages: typeSchema_1.pdfPageSelectionSchema.optional()
}).optional())
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_stampBarcode.bind(this))(barcodeValue, options);
});
}
//#endregion
//#region background/foreground
/**
* Adds a background to each page of this PDF. The background is copied from a first page in the
* backgroundPdf document.
*
* @param fromPdf background PDF document
* @param sourcePageIndex Index (zero-based page number) of the page to copy from the Background/Foreground PDF. Default is 0.
* @param applyToPages PageSelection to which the background/foreground will be added. Default is "all"
*/
addBackgroundFromAnotherPdf(fromPdf, sourcePageIndex = 0, applyToPages) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(pdfDocumentSchema_1.pdfDocumentSchema, typeSchema_1.numberSchema, typeSchema_1.pdfPageSelectionSchema.optional())
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_addBackgroundFromAnotherPdf.bind(this))(fromPdf, sourcePageIndex, applyToPages);
});
}
/**
* Adds a foreground to each page of this PDF. The background is copied from a first page in the
* backgroundPdf document.
*
* @param fromPdf foreground PDF document
* @param sourcePageIndex Index (zero-based page number) of the page to copy from the Background/Foreground PDF. Default is 0.
* @param applyToPages PageSelection to which the background/foreground will be added. Default is "all"
*/
addForegroundFromAnotherPdf(fromPdf, sourcePageIndex = 0, applyToPages) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(pdfDocumentSchema_1.pdfDocumentSchema, typeSchema_1.numberSchema, typeSchema_1.pdfPageSelectionSchema.optional())
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_addForegroundFromAnotherPdf.bind(this))(fromPdf, sourcePageIndex, applyToPages);
});
}
//#endregion
//#region security
/**
* Removes all user and owner password security for a PDF document. Also disables content
* encryption.
* If content is encrypted at 128 bit, copy and paste of content, annotations and form editing may be disabled.
*/
removePasswordsAndEncryption() {
return __awaiter(this, void 0, void 0, function* () {
return this.internal_removePasswordsAndEncryption();
});
}
/**
* Sets the user password and enables 128Bit encryption of PDF content.
* A user password is a password that each user must enter to open or print the PDF document.
*/
setUserPassword(userPassword) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(zod_1.z.string({ description: "userPassword: string" }))
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_setUserPassword.bind(this))(userPassword);
});
}
/**
* Sets the owner password and enables 128Bit encryption of PDF content. An owner password is one used to
* enable and disable all other security settings. <para>OwnerPassword must be set to a non-empty string
* value for {@link PdfPermission.AllowAccessibilityExtractContent} , {@link PdfPermission.AllowAnnotations} ,
* {@link PdfPermission.AllowFillForms}, {@link PdfPermission.AllowPrint}, {@link PdfPermission.AllowModify} to be
* restricted.
*/
setOwnerPassword(ownerPassword) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(zod_1.z.string({ description: "ownerPassword: string" }))
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_setOwnerPassword.bind(this))(ownerPassword);
});
}
/**
* Sets the permissions of this PdfDocument
* @param permissions see {@link PdfPermission}
*/
setPermission(permissions) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(securitySchema_1.pdfPermissionSchema)
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_setPermission.bind(this))(permissions);
});
}
/**
* Gets the current permissions of this PdfDocument
* @return {@link PdfPermission}
*/
getPermission() {
return __awaiter(this, void 0, void 0, function* () {
return this.internal_getPermission();
});
}
/**
* Makes this PDF document read only such that: Content is encrypted at 128 bit. Copy and paste of
* content is disallowed. Annotations and form editing are disabled.
* @param ownerPassword The owner password for the PDF. A string for owner password is required to enable PDF encryption and
* all document security options.
*/
makePdfDocumentReadOnly(ownerPassword) {
return __awaiter(this, void 0, void 0, function* () {
return zod_1.z.function()
.args(zod_1.z.string({ description: "ownerPassword: string" }))
.returns(zod_1.z.promise(zod_1.z.void()))
.implement(this.internal_makePdfDocumentReadOnly.bind(this))(ownerPassword);
});
}
//#endregion
//#region close
/**
* Dispose this PdfDocument object (clean up the resource)
* This is necessary to free the memory used by PdfDocument. See {@link cleanUp}
* Once this method was called this PdfDocument object no longer usable.
*/
close() {
return __awaiter(this, void 0, void 0, function* () {
return this.internal_close();
});
}
/**
* Create a PdfDocument object from a {@link PdfInput}
* For more specific way to create/open PdfDocument see {@link fromUrl} {@link fromZip} {@link fromHtml} {@link fromImage} {@link open}
*
* @param pdfInput see {@link PdfInput} (required) (pdfInput is {@link PdfFileP