@pdftools/four-heights-pdf-web-viewer 4.3.6

package/es6/pdf-viewer-api/PdfViewerApi.js

@@ -0,0 +1,732 @@
+import { PdfViewing } from '../pdf-viewing/PdfViewing';
+import { PdfItemCategory } from './enums';
+import { PdfViewingWrapper } from './PdfViewingWrapper';
+const checkType = (object, typeName, methodName, optional = false) => {
+    if (!optional && (object === null || typeof object !== typeName)) {
+        throw new TypeError(`Method ${methodName} requires argument of type '${typeName}' but is '${typeof object}'`);
+    }
+};
+const checkLicense = (instance) => {
+    if (!instance)
+        throw new Error('License is not set.');
+};
+export class PdfViewerApi {
+    constructor(pdfViewerApiOptions) {
+        this.eventListeners = new Map();
+        this.open = this.open.bind(this);
+        this.save = this.save.bind(this);
+        this.pdfViewerApiOptions = pdfViewerApiOptions;
+        /* iOS warns whenever an app uses resources too aggressively.
+         * For Cordova this plugin redirects this warning as an event to the document.
+         * When triggered flush the render cache.
+         * https://www.npmjs.com/package/cordova-plugin-memory-warning
+         */
+        // document.addEventListener('memorywarning', this.instance.forceFlushCache, {passive: false})
+    }
+    /**
+     *
+     * Open a PDF and optionally one or more associated FDF's.
+     * @param pdfFile           The PDF File that should be opened.
+     * @param fdfFiles         A list of FDF or XFDF files associated with this PDF that should be opened.
+     * @param password          The password used for opening this file.
+     * @param viewOptions       ViewOptions.
+     */
+    open(pdfFile, fdfFiles, password, viewOptions, renderOptions, viewportSize) {
+        checkLicense(this.instance);
+        return this.instance.open(pdfFile, fdfFiles, password, viewOptions, renderOptions, viewportSize);
+    }
+    /**
+     * Save the currently opened PDF file.
+     * @param fileType          Whether the file should be saved as
+     *                          a PDF containing the document and annotations,
+     *                          or an FDF containing ONLY the annotations.
+     *
+     * @returns                 A promise returning a memory buffer containing the saved file if resolved or an error message if rejected.
+     */
+    save(saveOptions) {
+        checkLicense(this.instance);
+        return this.instance.save(saveOptions);
+    }
+    /**
+     * Close the currently opened PDF file.
+     * @returns                 A promise returning nothing if resolved and an error message if rejected.
+     */
+    close() {
+        checkLicense(this.instance);
+        return this.instance.close();
+    }
+    /**
+     * dispose the api.
+     */
+    destroy() {
+        checkLicense(this.instance);
+        this.instance.destroy();
+    }
+    /**
+     * Registers pdf documents to use as stamp
+     *
+     */
+    registerPdfStampFile(pdfStampFileName, data, onStampCreated) {
+        checkLicense(this.instance);
+        this.instance.registerPdfStampFile(pdfStampFileName, data, onStampCreated);
+    }
+    /**
+     * Clear the rendered pages cache to free memory.
+     */
+    forceFlushCache() {
+        checkLicense(this.instance);
+        this.instance.forceFlushCache();
+    }
+    /**
+     * Get the current maximum size of the rendered pages cache.
+     * @returns                 The current maximum cache size in MB.
+     */
+    getMaxCacheSize() {
+        checkLicense(this.instance);
+        return this.instance.getMaxCacheSize();
+    }
+    /**
+     * Set the maximum size of the rendered pages cache.
+     * @param cacheSize         The maximum cache size in MB. Default is 120 MB.
+     */
+    setMaxCacheSize(cacheSize) {
+        checkLicense(this.instance);
+        this.instance.setMaxCacheSize(cacheSize);
+    }
+    /**
+     * Get the total page count of the opened document.
+     * @returns                 The total number of pages of the currently opened file.
+     *                          0 if no document is open.
+     */
+    getPageCount() {
+        checkLicense(this.instance);
+        return this.instance.getPageCount();
+    }
+    /**
+     * Get the page number of the first visible page.
+     * @returns                 The number of the topmost page shown in the viewport at this moment.
+     */
+    getPageNumber() {
+        checkLicense(this.instance);
+        return this.instance.getPageNumber();
+    }
+    getLastVisiblePage() {
+        checkLicense(this.instance);
+        return this.instance.getLastVisiblePage();
+    }
+    getFirstVisiblePage() {
+        checkLicense(this.instance);
+        return this.instance.getFirstVisiblePage();
+    }
+    /**
+     * Go to a given page.
+     * @param pageNumber        The number of the page to be shown in the viewport.
+     */
+    setPageNumber(pageNumber) {
+        checkType(pageNumber, 'number', 'setPageNumber');
+        checkLicense(this.instance);
+        this.instance.setPageNumber(pageNumber);
+    }
+    /**
+     * Get the viewer rotation.
+     * @returns                 The currently used viewer rotation on all pages.
+     */
+    getRotation() {
+        checkLicense(this.instance);
+        return this.instance.getRotation();
+    }
+    /**
+     * Set the viewer rotation.
+     * NOTE: This only changes the view of the document and is not an operation on the document.
+     * @param rotation          The rotation to be applied on all pages (cumulative with the embedded rotation per page).
+     */
+    setRotation(rotation) {
+        checkType(rotation, 'number', 'setRotation');
+        checkLicense(this.instance);
+        this.instance.setRotation(rotation);
+    }
+    /**
+     * Get the viewer zoom.
+     * @returns                 The currently used zoom factor.
+     */
+    getZoom() {
+        checkLicense(this.instance);
+        return this.instance.getZoom();
+    }
+    /**
+     * Set the viewer zoom.
+     * @param zoom              The zoom factor as a percentage of the original size.
+     */
+    setZoom(zoom, location) {
+        checkType(zoom, 'number', 'setZoom');
+        checkLicense(this.instance);
+        this.instance.setZoom(zoom, location);
+    }
+    /**
+     * Get the maximum scroll position.
+     * @returns                 The maximum scroll position in device pixels.
+     */
+    getScrollMaxPosition() {
+        checkLicense(this.instance);
+        return this.instance.getScrollMaxPosition();
+    }
+    /**
+     * Get the current scroll position.
+     * @returns                 The current scroll position in device pixels.
+     */
+    getScrollPosition() {
+        checkLicense(this.instance);
+        return this.instance.getScrollPosition();
+    }
+    /**
+     * Set the scroll position.
+     * @param pos               The scroll position to be shown in the viewer.
+     */
+    setScrollPosition(pos) {
+        checkLicense(this.instance);
+        this.instance.setScrollPosition(pos);
+    }
+    /**
+     * Jump to a given destination in the document.
+     * @param destination       The target destination in PDF coordinates (page origin bottom left)
+     */
+    goTo(destination) {
+        checkLicense(this.instance);
+        this.instance.goTo(destination);
+    }
+    /**
+     * Jump ot a given viewer destination in the document
+     * @param destination       The target destination in viewer coordinates (page origin top left)
+     */
+    goToViewerDestination(destination) {
+        checkLicense(this.instance);
+        this.instance.goTo(destination);
+    }
+    /**
+     * Navigate the viewport to show the given Rectangle by scrolling and zooming as little as possible.
+     * @param pdfRect       The target destination in PDF coordinates (page origin bottom left)
+     */
+    goToRectangle(rectangle) {
+        checkLicense(this.instance);
+        this.instance.goToRectangle(rectangle);
+    }
+    /**
+     * Check if a document is opened
+     * @returns                 Whether a file is opened by the viewer.
+     *                          A file counts as open if opening it has completed successfully
+     *                          and closing it has not started yet.
+     */
+    isOpen() {
+        checkLicense(this.instance);
+        return this.instance.getIsOpen();
+    }
+    /**
+     * Set the page layout mode.
+     * @param mode              The mode to be used for arranging pages on the canvas.
+     */
+    setPageLayoutMode(mode) {
+        checkLicense(this.instance);
+        this.instance.setPageLayoutMode(mode);
+    }
+    /**
+     * Get the current page layout mode.
+     * @returns                 The mode that is currently used for arranging pages on the canvas.
+     */
+    getPageLayoutMode() {
+        checkLicense(this.instance);
+        return this.instance.getPageLayoutMode();
+    }
+    /**
+     * Set the fit mode.
+     * @param fitMode           The mode to be used for fitting the viewport to the visible pages.
+     */
+    setFitMode(fitMode) {
+        checkLicense(this.instance);
+        this.instance.setFitMode(fitMode);
+    }
+    /**
+     * Get the current fit mode.
+     * @returns                 The mode that is currently used for fitting the viewport to the visible pages.
+     */
+    getFitMode() {
+        checkLicense(this.instance);
+        return this.instance.getFitMode();
+    }
+    /**
+     * Get the size of the border shown in between pages.
+     * @returns                 The border size in pixels at 100% zoom.
+     */
+    getBorderSize() {
+        checkLicense(this.instance);
+        return this.instance.getBorderSize();
+    }
+    /**
+     * Set the size of the border shown in between pages.
+     * @param borderSize          The border size in pixels at 100% zoom.
+     */
+    setBorderSize(borderSize) {
+        checkLicense(this.instance);
+        const ret = this.instance.setBorderSize(borderSize);
+        if (!ret.ok) {
+            throw new Error(ret.message);
+        }
+    }
+    /**
+     * Get the sliding window size.
+     * @returns                 The number of pages the viewer renders before and after the visible pages.
+     */
+    getSlidingWindowSize() {
+        checkLicense(this.instance);
+        return this.instance.getSlidingWindowSize();
+    }
+    /**
+     * Set the sliding window size.
+     * NOTE: Changing this value will impact caching behavior, because the sliding
+     * window has priority over cache size. This means that the cache can grow beyond
+     * the set cache limit if the sliding window is very large.
+     * @param slidingWindowSize The number of pages the viewer renders before and after the visible pages.
+     */
+    setSlidingWindowSize(slidingWindowSize) {
+        checkType(slidingWindowSize, 'number', 'setSlidingWindowSize');
+        checkLicense(this.instance);
+        const ret = this.instance.setSlidingWindowSize(slidingWindowSize);
+        if (!ret.ok) {
+            throw new Error(ret.message);
+        }
+    }
+    /**
+     * Suspend drawing for all actions until {@link PdfWebViewer#resumeDrawing|resumeDrawing} is called.
+     */
+    suspendDrawing() {
+        checkLicense(this.instance);
+        this.instance.suspendDrawing();
+    }
+    /**
+     * Resume drawing if currently suspended by {@link PdfWebViewer#suspendDrawing|suspendDrawing}.
+     * NOTE: previously given commands that have not yet been executed will not trigger separate render updates.
+     * However, a single render update will be made once all commands before the resumeDrawing call have been executed.
+     */
+    resumeDrawing() {
+        checkLicense(this.instance);
+        this.instance.resumeDrawing();
+    }
+    /**
+     * Draw into the canvas to update the viewport.
+     * This method has to be called whenever the canvas has been invalidated or after zoom/scroll.
+     * @param context           The canvas context in which the viewer will render.
+     */
+    renderCanvas(context, options) {
+        checkLicense(this.instance);
+        this.instance.renderCanvas(context, options);
+    }
+    /**
+     * Explicitly render a page with the given dimensions.
+     * The width and height will be adjusted to the aspect ratio of the page, clamping it to the smaller of the two values.
+     * @param pageNumber        The number of the page to be rendered.
+     * @param width             The width of the output file.
+     * @param height            The height of the output file.
+     * @param annotationFilter  Optional callback function to filter annotations during rendering.
+     *                          The result of the callback determines whether the annotation is included in the output.
+     * @returns                 A promise returning PageImage if resolved or returning an error message if rejected.
+     */
+    renderPage(pageNumber, width, height, annotationFilter) {
+        checkLicense(this.instance);
+        return this.instance.renderPage(pageNumber, width, height, annotationFilter);
+    }
+    rotatePage(pageNumber, direction) {
+        checkLicense(this.instance);
+        return this.instance.rotatePage(pageNumber, direction);
+    }
+    /**
+     * Returns the size of a PDF page
+     * @param pageNumber        The number of the page.
+     */
+    getPagePdfSize(pageNumber) {
+        checkLicense(this.instance);
+        return this.instance.getPagePdfSize(pageNumber);
+    }
+    /**
+     * Set whether embedded preferences for the startup viewport should be ignored
+     * when opening a PDF file (first shown page, fitmode etc.).
+     * @param ignore            Whether the embedded preferences should be ignored.
+     */
+    setIgnoringPreferences(ignore) {
+        checkLicense(this.instance);
+        this.instance.setIgnoringPreferences(ignore);
+    }
+    /**
+     * Get whether embedded preferences are ignored when opening a PDF file.
+     * @returns                 Whether embedded preferences are ignored.
+     */
+    getIgnoringPreferences() {
+        checkLicense(this.instance);
+        return this.instance.getIgnoringPreferences();
+    }
+    /**
+     * Get the product version of the viewer.
+     * @returns                 The product version of the PDF Web Viewer.
+     */
+    getProductVersion() {
+        return PdfViewing.Sdk.version;
+    }
+    /**
+     * Load outlines for a given parent.
+     * Can be used to call recursively on children which have descendants.
+     * @param parent            The parent outline item. If null then the root outline will be loaded.
+     * @returns                 A promise with the children of the parent outline.
+     */
+    getOutlines(parent) {
+        checkLicense(this.instance);
+        return this.instance.getOutlines(parent);
+    }
+    /**
+     * Get the text fragment located at a given position.
+     * @param point             The point in PDF coordinates.
+     * @returns                 The text fragment or null if no text fragment can be found at the given point.
+     */
+    getTextFragmentOnPoint(point) {
+        checkType(point, 'object', 'getTextFragmentOnPoint');
+        checkLicense(this.instance);
+        return this.instance.getTextFragmentOnPoint(point);
+    }
+    /**
+     * Get the text selection for a word located at a given position.
+     * @param point             The point in PDF coordinates.
+     * @returns                 The text selection or null if no word can be found at the given point.
+     */
+    getWordOnPoint(point) {
+        checkType(point, 'object', 'getWordOnPoint');
+        checkLicense(this.instance);
+        return this.instance.getWordOnPoint(point);
+    }
+    /**
+     * Get the text selection rectangles between the two points.
+     * @param startPoint        The starting point of the selection in PDF coordinates.
+     * @param endPoint          The end point of the selection in PDF coordinates.
+     * @returns                 The rectangles of the text fragments contained between the two points.
+     */
+    getTextSelection(startPoint, endPoint) {
+        checkLicense(this.instance);
+        return this.instance.getTextSelection(startPoint, endPoint);
+    }
+    /**
+     * Returns a text selection of all text within a rectangle.
+     * @param startPoint        The starting point of the selection in PDF coordinates.
+     * @param endPoint          The end point of the selection in PDF coordinates.
+     * @returns                 The rectangles of the text fragments contained between the two points.
+     */
+    getRectangularTextSelection(startPoint, endPoint) {
+        checkLicense(this.instance);
+        return this.instance.getRectangularTextSelection(startPoint, endPoint);
+    }
+    /**
+     * Get the text between the two points.
+     * @param startPoint        The starting point of the selection in PDF coordinates.
+     * @param endPoint          The end point of the selection in PDF coordinates.
+     * @returns                 The string of the selected text.
+     */
+    getText(startPoint, endPoint) {
+        checkLicense(this.instance);
+        return this.instance.getText(startPoint, endPoint);
+    }
+    /**
+     * Get the text within a rectangle.
+     * @param startPoint        The starting point of the selection in PDF coordinates.
+     * @param endPoint          The end point of the selection in PDF coordinates.
+     * @returns                 The string of the selected text.
+     */
+    getTextForRectangularSelection(startPoint, endPoint) {
+        checkLicense(this.instance);
+        return this.instance.getTextForRectangularSelection(startPoint, endPoint);
+    }
+    /**
+     * Get the text contained in given rectangles.
+     * @param selection         The rectangles in PDF coordinates.
+     * @returns                 The string of the selected text.
+     */
+    // public getTextFromSelection(selection: PdfRect[]): string {
+    //   checkLicense(this.instance)
+    //   return this.instance.getTextFromSelection(selection)
+    // }
+    /**
+     * Get the annotation located at a given point.
+     * @param point             The point in PDF coordinates.
+     * @returns                 The annotation or null.
+     */
+    getAnnotationsOnPoint(point, onlySelectable = false) {
+        checkLicense(this.instance);
+        return this.instance.getAnnotationsOnPoint(point, onlySelectable);
+    }
+    /**
+     * Get all open popups from <firstPage> to <lastPage>.
+     * @param firstPage         The first page.
+     * @param lastPage          The last page.
+     * @returns                 The list of annotations with an open popup in the given range.
+     */
+    getOpenPopups(firstPage, lastPage) {
+        checkLicense(this.instance);
+        return this.instance.getOpenPopups(firstPage, lastPage);
+    }
+    /**
+     * Load items of type {@link PdfItemCategory} for a given page.
+     * @param page              The page for which the items should be loaded.
+     * @param type              The type of item to be loaded. See {@link PdfItemCategory}.
+     * @returns                 The list of items.
+     */
+    getItemsFromPage(page, category) {
+        checkType(page, 'number', 'getItemsFromPage');
+        checkType(category, 'number', 'getItemsFromPage');
+        checkLicense(this.instance);
+        if (category === PdfItemCategory.ANNOTATION) {
+            return this.instance.getItemsFromPage(page, category);
+        }
+        else {
+            return new Promise((resolve, reject) => {
+                resolve({});
+            });
+        }
+    }
+    /**
+     * Create an annotation.
+     * Depending on the type of annotation the annotation args have to contain different arguments.
+     * See:
+     * {@link TextStampAnnotationArgs}
+     * {@link InkAnnotationArgs}
+     * {@link FreeTextAnnotationArgs}
+     * @param itemArgs          The arguments specific to the type of item to be created.
+     * @returns                 The created item.
+     */
+    createItem(itemArgs) {
+        checkType(itemArgs, 'object', 'createItem');
+        checkLicense(this.instance);
+        return this.instance.createItem(itemArgs);
+    }
+    /**
+     * Get the item for a given id.
+     * @param id                The id of the item.
+     * @returns                 A promise returning the item if resolved or returning an error message if rejected.
+     */
+    getItem(id) {
+        checkLicense(this.instance);
+        return this.instance.getItem(id);
+    }
+    /**
+     * Get the objects for given ids.
+     * @param ids               The ids of the items.
+     * @returns                 A promise returning a list of items if resolved or returning an error message if rejected.
+     */
+    getItems(ids) {
+        checkLicense(this.instance);
+        return this.instance.getItems(ids);
+    }
+    /**
+     * Update the editable fields of an item (e.g. an annotation).
+     * Please check the manual for more information about items and their fields.
+     * @param item              The item to be updated.
+     * @returns                 A promise returning the updated item if resolved or returning an error message if rejected.
+     */
+    updateItem(item) {
+        checkType(item, 'object', 'updateItem');
+        checkLicense(this.instance);
+        return this.instance.updateItem(item);
+    }
+    /**
+     * Delete an item (e.g. an annotation).
+     * Please check the manual for more information about items.
+     * @param item              The item to be deleted.
+     * @returns                 A promise returning nothing if resolved or returning an error message if rejected.
+     */
+    deleteItem(item) {
+        checkType(item, 'object', 'deleteItem');
+        checkLicense(this.instance);
+        return this.instance.deleteItem(item);
+    }
+    /**
+     * Get information about a particular stamp.
+     * Used for text stamps to retrieve the aspect ratio of the resulting stamp.
+     * @param args              stampType should be TEXT - stampText is the text of the stamp that should be displayed on the stamp annotation.
+     * @returns                 A promise returning stamp information such as aspect ratio if resolved.
+     */
+    getStampInfo(args) {
+        checkLicense(this.instance);
+        return this.instance.getStampInfo(args);
+    }
+    getTextStampAspectRatio(stampText) {
+        checkLicense(this.instance);
+        return this.instance.getTextStampAspectRatio(stampText);
+    }
+    /**
+     * Register an image stamp in the document. If the registration is successful the promise
+     * returns an ID > 0. This ID can then be used for the createItem method to create an image stamp
+     * with the given image ID
+     * @param image
+     * @returns                   A promise returning the ID
+     */
+    registerStampImage(image) {
+        checkType(image, 'object', 'registerStampImage');
+        checkLicense(this.instance);
+        return this.instance.registerImage(image);
+    }
+    /**
+     * Register an pdf page as stamp in the document. If the registration is successful the promise
+     * returns an ID > 0. This ID can then be used for the createItem method to create an image stamp
+     * with the given ID
+     * @param image
+     * @returns                   A promise returning the ID
+     */
+    registerPdfPage(fileName, pageNumber) {
+        checkType(fileName, 'string', 'registerPdfStamp');
+        checkType(pageNumber, 'number', 'registerPdfStamp');
+        checkLicense(this.instance);
+        return this.instance.registerPdfPage(fileName, pageNumber);
+    }
+    /**
+     * Check whether there are unsaved changes in the document.
+     * NOTE: When saving a document with unsaved changes
+     * - is successful: the promise resolves and the document is considered to be saved even if the array buffer with the saved document is discarded.
+     * - fails: the document is considered to contain unsaved changes.
+     * @returns                 True if there are unsaved changes, false otherwise.
+     */
+    hasChanges() {
+        checkLicense(this.instance);
+        return this.instance.hasChanges();
+    }
+    /**
+     * @param searchString      The string to be searched for.
+     * @param startPage         The page on which the search is started.
+     * @param caseSensitive     Whether the search should match case.
+     * @param wrapSearch        Whether the search should wrap around to the beginning when the end of the document is reached.
+     * @param useRegex          Whether the search should interpret the provided string as a regular expression.
+     * @returns                 A promise returning a {@link SearchResult} if resolved or returning an error message if rejected.
+     */
+    getSearchIterator(searchString, startPage, caseSensitive, wrapSearch, useRegex) {
+        return this.instance.getSearchIterator(searchString, startPage, caseSensitive, wrapSearch, useRegex);
+    }
+    /**
+     * Set the license key for the viewer.
+     * @param license           The license key.
+     * @returns                 True if license is correct else false
+     */
+    setLicenseKey(license) {
+        try {
+            this.instance = new PdfViewingWrapper(license, this.pdfViewerApiOptions);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /** internal */
+    getSupportedFeatures() {
+        return this.instance.getSupportedFeatures();
+    }
+    /**
+     * Convert a point from device coordinates to PDF coordinates.
+     * @param point                  The point in device coordinates.
+     * @param page                   The page relative to which the PDF coordinates should be calculated.
+     * @param guaranteePointIsOnPage This parameter will fix the isOnPage boolean of the return value to true.
+     *                               Due to conversions back and forth from CSS to PDF and vice versa,
+     *                               a CSS coordinate could return isOnPage=False even if the mouse movement
+     *                               has been restricted to the page. Only set this to true if the
+     *                               device point is certainly on the page.
+     * @returns                      The point in PDF coordinates, including the number of the page where it is located.
+     */
+    transformScreenPointToPdfPoint(point, page, guaranteePointIsOnPage) {
+        checkType(point.x, 'number', 'x');
+        checkType(point.y, 'number', 'y');
+        checkLicense(this.instance);
+        if (page !== undefined) {
+            checkType(page, 'number', 'page');
+        }
+        if (guaranteePointIsOnPage !== undefined) {
+            checkType(guaranteePointIsOnPage, 'boolean', 'transformScreenPointToPdf');
+        }
+        return this.instance.transformScreenPointToPdfPoint(point, page, guaranteePointIsOnPage);
+    }
+    getClosestPointOnPdfByScreenPoint(point, padding = 0, page) {
+        checkLicense(this.instance);
+        return this.instance.getClosestPointOnPdfByScreenPoint(point, page, padding);
+    }
+    transformPdfPointToScreenPoint(pdfPoint) {
+        checkType(pdfPoint.pdfX, 'number', 'pdfX');
+        checkType(pdfPoint.pdfY, 'number', 'pdfY');
+        checkType(pdfPoint.page, 'number', 'page');
+        checkLicense(this.instance);
+        return this.instance.transformPdfPointToScreenPoint(pdfPoint);
+    }
+    /**
+     * Convert a rectangle from device coordinates to PDF coordinates.
+     * @param rect              The rectangle in device coordinates.
+     * @returns                 The rectangle in PDF coordinates, including the number of the page where it is located.
+     */
+    transformScreenRectToPdfRect(rect, page) {
+        checkType(rect.x, 'number', 'x');
+        checkType(rect.y, 'number', 'y');
+        checkType(rect.w, 'number', 'w');
+        checkType(rect.h, 'number', 'h');
+        checkLicense(this.instance);
+        return this.instance.transformScreenRectToPdfRect(rect, page);
+    }
+    /**
+     * Convert a rectangle from PDF coordinates to device coordinates.
+     * @param pdfRect           The rectangle in PDF coordinates.
+     * @returns Rect            The rectangle in device coordinates.
+     */
+    transformPdfPageRectToScreenRect(pdfRect) {
+        checkType(pdfRect.pdfX, 'number', 'pdfX');
+        checkType(pdfRect.pdfY, 'number', 'pdfY');
+        checkType(pdfRect.pdfW, 'number', 'pdfW');
+        checkType(pdfRect.pdfH, 'number', 'pdfH');
+        checkType(pdfRect.page, 'number', 'page');
+        checkLicense(this.instance);
+        let ret = this.instance.transformPdfPageRectToScreenRect(pdfRect);
+        return ret;
+    }
+    /**
+     * Convert a length from PDF units to device pixels.
+     * @param pdfLength         The length in PDF units.
+     * @returns number          The length in device pixels.
+     */
+    transformPdfLengthToScreenLength(pdfLength) {
+        checkType(pdfLength, 'number', 'transformPdfLengthToScreenLength');
+        checkLicense(this.instance);
+        return this.instance.transformPdfLengthToScreenLength(pdfLength);
+    }
+    /**
+     * Convert a length from device pixels to PDF units.
+     * @param screenLength      The length in device pixels.
+     * @returns number          The length in PDF units.
+     */
+    transformScreenLengthToPdfLength(screenLength) {
+        checkType(screenLength, 'number', 'transformScreenLengthToPdfLength');
+        checkLicense(this.instance);
+        return this.instance.transformScreenLengthToPdfLength(screenLength);
+    }
+    /**
+     * Convert a length from PDF units to device pixels.
+     * @param pdfLength         The length in PDF units.
+     * @returns number          The length in device pixels.
+     */
+    transformQuadrilateralToViewport(quadrilateral) {
+        checkLicense(this.instance);
+        return this.instance.transformQuadrilateralToViewport(quadrilateral);
+    }
+    /**
+     * Get the screen rectangle of a page to know its position inside the viewport.
+     * @param pageNumber        The number of the page.
+     * @returns                 The rectangle with the page coordinates in device pixels.
+     *                          Null if no document is opened or the page is invalid.
+     */
+    getPageScreenRect(pageNumber) {
+        checkLicense(this.instance);
+        return this.instance.getPageScreenRect(pageNumber);
+    }
+    addEventListener(type, listener) {
+        checkLicense(this.instance);
+        this.instance.addEventListener(type, listener);
+    }
+    removeEventListener(type, listener) {
+        checkLicense(this.instance);
+        this.instance.removeEventListener(type, listener);
+    }
+}