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

package/es6/pdf-web-viewer/PdfWebViewer.js

@@ -0,0 +1,1386 @@
+import { PdfViewing } from '../pdf-viewing/PdfViewing';
+import { app } from '../lib/hyperapp';
+import { App } from './views/App';
+import { FileType, } from '../pdf-viewer-api/types';
+import { PdfItemCategory, } from '../pdf-viewer-api';
+import { PdfViewerCanvas } from '../pdf-viewer-canvas/PdfViewerCanvas';
+import { createState, actions } from './state/index';
+import { DeviceType, ScreenSize } from './state/layout';
+import { translationManager } from '../common/TranslationManager';
+import { tooltipManager } from '../common/TooltipManager';
+import { ColorPaletteMap, OptionsToVerify, WebViewerOptions, } from './WebViewerOptions';
+import { getKeyboardCommands } from '../common/utils';
+export class PdfWebViewer {
+    constructor(containerElement, license, options) {
+        this.visiblePageRange = {
+            firstPage: 0,
+            lastPage: 0,
+        };
+        this.eventListeners = new Map();
+        this.loadThumbnailsQueue = [];
+        this.loadPageThumbnailsTimer = null;
+        this.metadata = {
+            version: '4.3.6',
+            type: 'stable',
+        };
+        if (!containerElement) {
+            throw { error: 'PdfWebViewer container element is null' };
+        }
+        this.licenseKey = license;
+        this.element = containerElement;
+        this.options = new WebViewerOptions(options);
+        if (options) {
+            this.verifyOptions(options, this.options);
+        }
+        this.handleKeyboardShortcuts = this.handleKeyboardShortcuts.bind(this);
+        this.createView = this.createView.bind(this);
+        this.loadPageThumbnails = this.loadPageThumbnails.bind(this);
+        this.loadDocumentOutlines = this.loadDocumentOutlines.bind(this);
+        this.handleAppLoaded = this.handleAppLoaded.bind(this);
+        this.handleResize = this.handleResize.bind(this);
+        this.getScreenSize = this.getScreenSize.bind(this);
+        this.handleDocumentOpened = this.handleDocumentOpened.bind(this);
+        this.handleDocumentClosed = this.handleDocumentClosed.bind(this);
+        this.handleFirstVisiblePageChanged = this.handleFirstVisiblePageChanged.bind(this);
+        this.handleLastVisiblePageChanged = this.handleLastVisiblePageChanged.bind(this);
+        this.handlePageNumberChanged = this.handlePageNumberChanged.bind(this);
+        this.handleZoomChanged = this.handleZoomChanged.bind(this);
+        this.handleRotationChanged = this.handleRotationChanged.bind(this);
+        this.handleFitModeChanged = this.handleFitModeChanged.bind(this);
+        this.handlePageLayoutModeChanged = this.handlePageLayoutModeChanged.bind(this);
+        this.handleBusyStateChanged = this.handleBusyStateChanged.bind(this);
+        this.handlePageChanged = this.handlePageChanged.bind(this);
+        this.handleTextSelected = this.handleTextSelected.bind(this);
+        this.handleError = this.handleError.bind(this);
+        this.addPagesToThumbnailsQueue = this.addPagesToThumbnailsQueue.bind(this);
+        this.handleAnnotationCreated = this.handleAnnotationCreated.bind(this);
+        this.handleAnnotationUpdated = this.handleAnnotationUpdated.bind(this);
+        this.handleAnnotationDeleted = this.handleAnnotationDeleted.bind(this);
+        this.handleAnnotationSelected = this.handleAnnotationSelected.bind(this);
+        this.handleAnnotationDeselected = this.handleAnnotationDeselected.bind(this);
+        this.showUnconfirmedChangesDialog = this.showUnconfirmedChangesDialog.bind(this);
+        document.addEventListener('keydown', this.handleKeyboardShortcuts, false);
+        const resizeObserver = new ResizeObserver(this.handleResize);
+        resizeObserver.observe(this.element);
+        tooltipManager.setType(this.options.viewer.general.tooltips || 'title');
+        const initialState = createState(this.options);
+        initialState.layout.deviceType = /iPhone|iPad|iPod|Android|mobile/i.test(navigator.userAgent)
+            ? DeviceType.Mobile
+            : DeviceType.Desktop;
+        initialState.layout.screenSize = this.getScreenSize();
+        this.view = this.createView(app)(initialState, actions, App, this.element);
+    }
+    /**
+     * Open a PDF and optionally one or more associated FDFs.
+     * @param pdfFile
+     * The PDF file to be opened.
+     * @param fdfFiles
+     * An array of FDF files to be opened jointly with the PDF.
+     * Set to `null` if no FDF files need to be opened.
+     * @param password
+     * The password used for opening the PDF.
+     * Set to `null` if the PDF is not encrypted.
+     * @param renderOptions
+     * Options used for rendering pages.
+     * @param viewOptions
+     * Options used for configuring the view
+     * @returns
+     * void
+     */
+    open(pdfFile, fdfFiles, password, viewOptions, renderOptions) {
+        var _a;
+        (_a = this.view) === null || _a === void 0 ? void 0 : _a.api.open({
+            pdfFile,
+            fdfFiles,
+            password,
+            viewOptions,
+            renderOptions,
+        });
+    }
+    /**
+     * @deprecated Deprecated in Version 3.10. Use save method instead.
+     */
+    openFile(file, password, pdfAuthorization) {
+        let inputFile = undefined;
+        if (typeof file === 'string') {
+            inputFile = { uri: file };
+            if (pdfAuthorization) {
+                inputFile.httpOptions = {
+                    headers: {
+                        Authorization: pdfAuthorization,
+                    },
+                };
+            }
+        }
+        else {
+            inputFile = { data: file };
+        }
+        this.open(inputFile, null, password);
+    }
+    /**
+     * @deprecated Deprecated in Version 3.10. Use save method instead.
+     */
+    openFDF(pdfFile, fdfFile, password, pdfAuthorization, fdfAuthorization) {
+        let pdfInputFile = undefined;
+        if (typeof pdfFile === 'string') {
+            pdfInputFile = { uri: pdfFile };
+            if (pdfAuthorization) {
+                pdfInputFile.httpOptions = {
+                    headers: {
+                        Authorization: pdfAuthorization,
+                    },
+                };
+            }
+        }
+        else {
+            pdfInputFile = { data: pdfFile };
+        }
+        const fdfInputFile = typeof fdfFile === 'string'
+            ? { uri: fdfFile }
+            : { data: fdfFile };
+        this.open(pdfInputFile, [fdfInputFile], password);
+    }
+    /**
+     * Return the opened PDF as binary data,
+     * to be used, e.g., to save the file to disk.
+     * @param saveOptions
+     * Options for saving the document
+     * @returns
+     * A Promise with an Blob containing the data or null if no document is open
+     *
+     */
+    save(saveOptions) {
+        return this.viewerCanvas ? this.viewerCanvas.save(saveOptions) : null;
+    }
+    /**
+     * @deprecated Deprecated in Version 3.10. Use save method instead.
+     */
+    saveFile(asFdf) {
+        return new Promise((resolve, reject) => {
+            var _a;
+            const fileType = asFdf ? FileType.Fdf : FileType.Pdf;
+            (_a = this.save({ fileType })) === null || _a === void 0 ? void 0 : _a.then((blob) => {
+                resolve(blob.arrayBuffer());
+            });
+        });
+    }
+    /**
+     * saves the currently opened PDF file to the local file system
+     */
+    downloadFile(saveOptions) {
+        if (this.view) {
+            return this.view.api.downloadFile(saveOptions);
+        }
+    }
+    /**
+     * Close the currently opened PDF file.
+     */
+    close() {
+        if (this.view) {
+            return this.view.api.close();
+        }
+    }
+    /**
+     * dispose the PdfWebViewer.
+     */
+    destroy() {
+        var _a;
+        // remove all event listeners
+        document.removeEventListener('keydown', this.handleKeyboardShortcuts, false);
+        this.eventListeners.clear();
+        if (this.viewerCanvas) {
+            this.viewerCanvas.removeEventListener('appLoaded', this.handleAppLoaded);
+            this.viewerCanvas.removeEventListener('firstVisiblePage', this.handleFirstVisiblePageChanged);
+            this.viewerCanvas.removeEventListener('lastVisiblePage', this.handleLastVisiblePageChanged);
+            this.viewerCanvas.removeEventListener('pageNumber', this.handlePageNumberChanged);
+            this.viewerCanvas.removeEventListener('zoom', this.handleZoomChanged);
+            this.viewerCanvas.removeEventListener('fitMode', this.handleFitModeChanged);
+            this.viewerCanvas.removeEventListener('pageLayoutMode', this.handlePageLayoutModeChanged);
+            this.viewerCanvas.removeEventListener('busyState', this.handleBusyStateChanged);
+            this.viewerCanvas.removeEventListener('rotation', this.handleRotationChanged);
+            this.viewerCanvas.removeEventListener('pageChanged', this.handlePageChanged);
+            this.viewerCanvas.removeEventListener('error', this.handleError);
+            this.viewerCanvas.removeEventListener('itemCreated', this.handleAnnotationCreated);
+            this.viewerCanvas.removeEventListener('itemUpdated', this.handleAnnotationUpdated);
+            this.viewerCanvas.removeEventListener('itemDeleted', this.handleAnnotationDeleted);
+            this.viewerCanvas.removeEventListener('itemSelected', this.handleAnnotationSelected);
+            this.viewerCanvas.removeEventListener('itemDeselected', this.handleAnnotationDeselected);
+        }
+        // destroy viewer canvas
+        (_a = this.viewerCanvas) === null || _a === void 0 ? void 0 : _a.destroy();
+        this.viewerCanvas = undefined;
+        this.view = undefined;
+        this.loadThumbnailsQueue = [];
+        if (this.loadPageThumbnailsTimer) {
+            clearTimeout(this.loadPageThumbnailsTimer);
+        }
+        // remove all child elements
+        while (this.element.firstChild) {
+            this.element.removeChild(this.element.firstChild);
+        }
+    }
+    /**
+     * Get the total page count of the opened document.
+     * @returns
+     * The total number of pages of the currently opened file.
+     * Returns null if no document is open
+     */
+    getPageCount() {
+        return this.viewerCanvas ? this.viewerCanvas.getPageCount() : null;
+    }
+    /**
+     * Get the currently most visible page.
+     * @returns
+     * The number of the page which covers most area on the view port.
+     * If multiple pages cover the same amount of space,
+     * the one with smaller page number is returned.
+     * Returns null if no document is open
+     */
+    getPageNumber() {
+        if (this.viewerCanvas) {
+            return this.viewerCanvas.getPageNumber();
+        }
+        return null;
+    }
+    /**
+     * Sets the first currently visible page.
+     * @param pageNumber
+     * The number of the page to be displayed
+     */
+    setPageNumber(pageNumber) {
+        if (this.viewerCanvas) {
+            this.viewerCanvas.setPageNumber(pageNumber);
+        }
+    }
+    /**
+     * Rotates a page 90 degrees either clockwise or counterclockwise
+     *
+     * @param pageNumber
+     * The number of the page to be rotated
+     * @param direction
+     * Specifies whether the rotation is clockwise or counterclockwise.
+     */
+    rotatePage(pageNumber, direction) {
+        if (this.viewerCanvas) {
+            this.viewerCanvas.rotatePage(pageNumber, direction);
+        }
+    }
+    /**
+     * Go to the next page.
+     */
+    nextPage() {
+        if (this.viewerCanvas) {
+            this.viewerCanvas.nextPage();
+        }
+    }
+    /**
+     * Go to the previousPage page.
+     */
+    previousPage() {
+        if (this.viewerCanvas) {
+            this.viewerCanvas.previousPage();
+        }
+    }
+    /**
+     * Get the viewer zoom.
+     * @returns
+     * The currently used zoom factor.
+     * Returns null if no document is open.
+     */
+    getZoom() {
+        if (this.viewerCanvas) {
+            return this.viewerCanvas.getZoom();
+        }
+        return null;
+    }
+    /**
+     * Set the viewer zoom.
+     * @param zoom
+     * The zoom factor as a percentage of the original size.
+     */
+    setZoom(zoom) {
+        if (this.viewerCanvas) {
+            this.viewerCanvas.setZoom(zoom);
+        }
+    }
+    /**
+     * Sets the zoom to the closest higher predefined zoom Level.
+     */
+    zoomIn() {
+        var _a;
+        (_a = this.viewerCanvas) === null || _a === void 0 ? void 0 : _a.zoomIn();
+    }
+    /**
+     * Sets the zoom to the closest smaller predefined zoom Level.
+     */
+    zoomOut() {
+        var _a;
+        (_a = this.viewerCanvas) === null || _a === void 0 ? void 0 : _a.zoomOut();
+    }
+    /**
+     * Get the current fit mode.
+     * @returns
+     * The mode that is currently used for fitting the viewport to the visible pages.
+     * Returns null if no document is open.
+     */
+    getFitMode() {
+        if (this.viewerCanvas) {
+            return this.viewerCanvas.getFitMode();
+        }
+        return null;
+    }
+    /**
+     * Set the fit mode.
+     * @param fitMode
+     * The mode to be used for fitting the viewport to the visible pages.
+     */
+    setFitMode(fitMode) {
+        if (this.viewerCanvas) {
+            this.viewerCanvas.setFitMode(fitMode);
+        }
+    }
+    /**
+     * Get the current page layout mode.
+     * @returns
+     * The mode that is currently used for arranging pages on the canvas.
+     * Returns null if no document is open.
+     */
+    getPageLayoutMode() {
+        if (this.viewerCanvas) {
+            return this.viewerCanvas.getPageLayoutMode();
+        }
+        return null;
+    }
+    /**
+     * Set the page layout mode.
+     * @param pageLayoutMode
+     * The mode to be used for arranging pages on the canvas.
+     */
+    setPageLayoutMode(pageLayoutMode) {
+        if (this.viewerCanvas) {
+            this.viewerCanvas.setPageLayoutMode(pageLayoutMode);
+        }
+    }
+    /**
+     * Get the viewer rotation.
+     * @returns
+     * The currently used viewer rotation on all pages.
+     * Returns null if no document is open
+     */
+    getRotation() {
+        if (this.viewerCanvas) {
+            return this.viewerCanvas.getRotation();
+        }
+        return null;
+    }
+    /**
+     * 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) {
+        if (this.viewerCanvas) {
+            this.viewerCanvas.setRotation(rotation);
+        }
+    }
+    /**
+     * Get the product version of the viewer.
+     * @returns
+     * The product version of the PDF Web Viewer.
+     */
+    getProductVersion() {
+        return PdfViewing.Sdk.version;
+    }
+    /**
+     * Get the metadata of the viewer.
+     * @returns
+     * The metadata of the PDF Web Viewer.
+     */
+    getMetadata() {
+        return this.metadata;
+    }
+    /**
+     * Check whether there are unsaved changes in the document.
+     * @returns
+     * A DocumentChange enum indicating what kind of changes were made
+     * Returns null if no document is open
+     */
+    hasChanges() {
+        if (this.view) {
+            return this.view.api.hasChanges();
+        }
+        return null;
+    }
+    /**
+     * Opens the information pane and selects the given pane
+     * @selectedPane
+     * Name of the pane thath should be displayed
+     */
+    showInformationPane(selectedPane) {
+        if (this.view) {
+            if (selectedPane) {
+                this.view.navigationPanel.selectNavigation(selectedPane);
+            }
+            else {
+                this.view.navigationPanel.showNavigationPanel();
+            }
+        }
+    }
+    /**
+     * Closes the information pane
+     */
+    hideInformationPane() {
+        if (this.view) {
+            this.view.navigationPanel.hideNavigationPanel();
+        }
+    }
+    /**
+     * Toggle the information pane
+     */
+    toggleInformationPane() {
+        if (this.view) {
+            this.view.navigationPanel.toggleNavigationPanel();
+        }
+    }
+    /**
+     * Opens the search tool bar and starts a new search with the given text
+     * @param text
+     * text to be searched for
+     * @param searchOptions
+     * Options for be used for searching
+     */
+    startSearch(searchString, searchOptions) {
+        if (this.view && this.viewerCanvas) {
+            const { startPage, isCaseSensitive, isWrappingEnabled, isRegex, hideToolbar } = searchOptions || {};
+            const caseSensitive = Boolean(isCaseSensitive);
+            const wrappingEnabled = Boolean(isWrappingEnabled);
+            const regex = Boolean(isRegex);
+            if (!hideToolbar) {
+                this.view.search.openSearch();
+                this.view.search.updateToSearch(searchString);
+                this.view.search.setCaseSensitive(caseSensitive);
+                this.view.search.setWrappingSearch(wrappingEnabled);
+                this.view.search.setRegex(regex);
+            }
+            this.viewerCanvas.startSearch(searchString, startPage || 1, caseSensitive, wrappingEnabled, regex);
+        }
+    }
+    /**
+     * Highlights the next search result
+     */
+    nextSearchMatch() {
+        if (this.viewerCanvas) {
+            this.viewerCanvas.nextSearchMatch();
+        }
+    }
+    /**
+     * Highlights the previous search result
+     */
+    previousSearchMatch() {
+        if (this.viewerCanvas) {
+            this.viewerCanvas.previousSearchMatch();
+        }
+    }
+    /**
+     * Stops the current search and closes the search tool bar
+     */
+    endSearch() {
+        if (this.view) {
+            this.view.api.endSearch();
+            this.view.search.closeSearch();
+        }
+    }
+    /**
+     * Opens the print dialog
+     */
+    print() {
+        var _a;
+        (_a = this.viewerCanvas) === null || _a === void 0 ? void 0 : _a.print();
+    }
+    /**
+     * Returns the selected text
+     */
+    getSelectedText() {
+        var _a, _b;
+        return (_b = (_a = this.viewerCanvas) === null || _a === void 0 ? void 0 : _a.getSelectedText()) !== null && _b !== void 0 ? _b : '';
+    }
+    /**
+     * Register a function that will be called whenever the specified event is delivered
+     * @param type
+     * String representing the event type to listen for.
+     * @param listener
+     * The function that will be executet when an event of the specified type occurs
+     */
+    addEventListener(type, listener) {
+        if (this.eventListeners.has(type)) {
+            ;
+            this.eventListeners.get(type).push(listener);
+        }
+        else {
+            this.eventListeners.set(type, [listener]);
+        }
+    }
+    /**
+     * Removes an event listener previously registered with addEventListener
+     * @param type
+     * String representing the event for which to remove an event listener.
+     * @param listener
+     * The event listener function of the event handler to remove from the event target.
+     */
+    removeEventListener(type, listener) {
+        if (this.eventListeners.has(type)) {
+            let listeners = this.eventListeners.get(type);
+            listeners = listeners.filter((listenerInArray) => listenerInArray !== listener);
+            if (listeners.length !== 0) {
+                this.eventListeners.set(type, listeners);
+            }
+            else {
+                this.eventListeners.delete(type);
+            }
+        }
+    }
+    dispatchEvent(type, args) {
+        if (this.eventListeners.has(type)) {
+            const listeners = this.eventListeners.get(type);
+            listeners.forEach((listener) => listener(args));
+        }
+    }
+    createView(nextApp) {
+        return (state, a, view, element) => {
+            a.initialize = () => {
+                const loadTranslationPromise = translationManager.loadTranslations(this.options.viewer.general.language || 'en');
+                Promise.all([window.PdfToolsPromise, loadTranslationPromise])
+                    .then(() => {
+                    var _a;
+                    (_a = this.view) === null || _a === void 0 ? void 0 : _a.loadScriptsCompleted();
+                })
+                    .catch((err) => {
+                    this.handleError(err);
+                });
+            };
+            a.createCanvasView = (elm) => {
+                try {
+                    this.viewerCanvas = new PdfViewerCanvas(elm, this.licenseKey, this.options);
+                }
+                catch (err) {
+                    this.handleError(err);
+                    return;
+                }
+                this.viewerCanvas.addEventListener('appLoaded', this.handleAppLoaded);
+                this.viewerCanvas.addEventListener('firstVisiblePage', this.handleFirstVisiblePageChanged);
+                this.viewerCanvas.addEventListener('lastVisiblePage', this.handleLastVisiblePageChanged);
+                this.viewerCanvas.addEventListener('pageNumber', this.handlePageNumberChanged);
+                this.viewerCanvas.addEventListener('zoom', this.handleZoomChanged);
+                this.viewerCanvas.addEventListener('fitMode', this.handleFitModeChanged);
+                this.viewerCanvas.addEventListener('rotation', this.handleRotationChanged);
+                this.viewerCanvas.addEventListener('pageLayoutMode', this.handlePageLayoutModeChanged);
+                this.viewerCanvas.addEventListener('busyState', this.handleBusyStateChanged);
+                this.viewerCanvas.addEventListener('pageChanged', this.handlePageChanged);
+                this.viewerCanvas.addEventListener('textSelected', this.handleTextSelected);
+                this.viewerCanvas.addEventListener('error', this.handleError);
+                /*** annotation events  */
+                this.viewerCanvas.addEventListener('itemCreated', this.handleAnnotationCreated);
+                this.viewerCanvas.addEventListener('itemUpdated', this.handleAnnotationUpdated);
+                this.viewerCanvas.addEventListener('itemDeleted', this.handleAnnotationDeleted);
+                this.viewerCanvas.addEventListener('itemSelected', this.handleAnnotationSelected);
+                this.viewerCanvas.addEventListener('itemDeselected', this.handleAnnotationDeselected);
+                const params = new URLSearchParams(location.search);
+                if (params) {
+                    const pdfUrl = params.get('url');
+                    if (pdfUrl) {
+                        this.open({ uri: pdfUrl, sourceTag: '' });
+                    }
+                }
+            };
+            a.removeCanvasView = (elm) => {
+                if (this.viewerCanvas) {
+                    this.viewerCanvas.removeEventListener('firstVisiblePage', this.handleFirstVisiblePageChanged);
+                    this.viewerCanvas.removeEventListener('lastVisiblePage', this.handleLastVisiblePageChanged);
+                    this.viewerCanvas.removeEventListener(`pageNumber`, this.handlePageNumberChanged);
+                    this.viewerCanvas.removeEventListener('zoom', this.handleZoomChanged);
+                    this.viewerCanvas.removeEventListener('fitMode', this.handleFitModeChanged);
+                    this.viewerCanvas.removeEventListener('pageLayoutMode', this.handlePageLayoutModeChanged);
+                    this.viewerCanvas.removeEventListener('busyState', this.handleBusyStateChanged);
+                    this.viewerCanvas.removeEventListener('error', this.handleError);
+                    this.viewerCanvas = undefined;
+                }
+            };
+            a.api = {
+                open: (args) => {
+                    if (this.view) {
+                        this.view.loadDocumentBegin();
+                        if (this.viewerCanvas) {
+                            if (!this.beforeOpen(args)) {
+                                return;
+                            }
+                            if (this.viewerCanvas) {
+                                this.viewerCanvas
+                                    .open(args.pdfFile, args.fdfFiles, args.password, args.viewOptions, args.renderOptions)
+                                    .then(() => {
+                                    this.openResolve(args);
+                                })
+                                    .catch((error) => {
+                                    this.openReject(args, error);
+                                });
+                            }
+                        }
+                    }
+                },
+                close: () => {
+                    if (this.view && this.viewerCanvas) {
+                        if (this.showUnconfirmedChangesDialog()) {
+                            this.view.showConfirmUnsavedChangesDialog(null, this.handleDocumentClosed);
+                            return;
+                        }
+                        this.handleDocumentClosed();
+                    }
+                },
+                downloadFile: (saveOptions) => {
+                    return new Promise((resolve, reject) => {
+                        if (this.view && this.viewerCanvas) {
+                            this.view.saveDocumentBegin();
+                            const viewState = this.view.getState();
+                            const filename = viewState.pdfDocument.filename;
+                            const mimetype = viewState.pdfDocument.mimetype;
+                            this.viewerCanvas
+                                .save(saveOptions)
+                                .then((data) => {
+                                const newBlob = new Blob([data], { type: mimetype });
+                                const dataUrl = window.URL.createObjectURL(newBlob);
+                                const link = document.createElement('a');
+                                link.style.position = 'absolute';
+                                link.style.left = '-1000px';
+                                link.href = dataUrl;
+                                link.download = filename || 'download.pdf';
+                                this.element.appendChild(link);
+                                link.click();
+                                setTimeout(() => {
+                                    var _a;
+                                    this.element.removeChild(link);
+                                    window.URL.revokeObjectURL(dataUrl);
+                                    (_a = this.view) === null || _a === void 0 ? void 0 : _a.saveDocumentFulfilled();
+                                }, 100);
+                                resolve();
+                            })
+                                .catch((error) => {
+                                var _a;
+                                console.error(error);
+                                (_a = this.view) === null || _a === void 0 ? void 0 : _a.saveDocumentRejected(error);
+                            });
+                        }
+                    });
+                },
+                hasChanges: () => {
+                    if (this.viewerCanvas) {
+                        return this.viewerCanvas.hasChanges();
+                    }
+                    return null;
+                },
+                setZoom: (zoom) => {
+                    if (this.viewerCanvas) {
+                        this.viewerCanvas.setZoom(zoom / 100);
+                    }
+                },
+                getZoom: () => {
+                    if (this.viewerCanvas) {
+                        return this.viewerCanvas.getZoom();
+                    }
+                    return null;
+                },
+                zoomIn: () => {
+                    if (this.viewerCanvas) {
+                        this.viewerCanvas.zoomIn();
+                    }
+                },
+                zoomOut: () => {
+                    if (this.viewerCanvas) {
+                        this.viewerCanvas.zoomOut();
+                    }
+                },
+                setPageNumber: (page) => {
+                    if (this.viewerCanvas) {
+                        this.viewerCanvas.setPageNumber(page);
+                    }
+                },
+                getPageNumber: () => {
+                    if (this.viewerCanvas) {
+                        return this.viewerCanvas.getPageNumber();
+                    }
+                    return null;
+                },
+                getPageCount: () => {
+                    if (this.viewerCanvas) {
+                        return this.viewerCanvas.getPageCount();
+                    }
+                    return null;
+                },
+                nextPage: () => {
+                    if (this.viewerCanvas) {
+                        this.viewerCanvas.nextPage();
+                    }
+                },
+                previousPage: () => {
+                    if (this.viewerCanvas) {
+                        this.viewerCanvas.previousPage();
+                    }
+                },
+                setFitMode: (fitMode) => {
+                    if (this.viewerCanvas) {
+                        this.viewerCanvas.setFitMode(fitMode);
+                    }
+                },
+                getFitMode: () => {
+                    if (this.viewerCanvas) {
+                        return this.viewerCanvas.getFitMode();
+                    }
+                    return null;
+                },
+                setPageLayoutMode: (layoutMode) => {
+                    if (this.viewerCanvas) {
+                        this.viewerCanvas.setPageLayoutMode(layoutMode);
+                    }
+                },
+                getPageLayoutMode: () => {
+                    if (this.viewerCanvas) {
+                        return this.viewerCanvas.getPageLayoutMode();
+                    }
+                    return null;
+                },
+                rotatePage: (pageRotation) => {
+                    if (this.viewerCanvas) {
+                        return this.viewerCanvas.rotatePage(pageRotation.page, pageRotation.direction);
+                    }
+                },
+                rotate: () => {
+                    if (this.viewerCanvas) {
+                        const r = this.viewerCanvas.getRotation();
+                        const rotation = r >= 270 ? 0 : r + 90;
+                        this.viewerCanvas.setRotation(rotation);
+                    }
+                },
+                setRotation: (rotation) => {
+                    if (this.viewerCanvas) {
+                        this.viewerCanvas.setRotation(rotation);
+                    }
+                },
+                getRotation: () => {
+                    if (this.viewerCanvas) {
+                        return this.viewerCanvas.getRotation();
+                    }
+                    return null;
+                },
+                startSearch: () => {
+                    if (this.view && this.viewerCanvas) {
+                        const s = this.view.getState().search;
+                        this.viewerCanvas.startSearch(s.searchString, 1, s.caseSensitive, s.wrapSearch, s.useRegex);
+                    }
+                },
+                nextSearchMatch: () => {
+                    if (this.viewerCanvas) {
+                        this.viewerCanvas.nextSearchMatch();
+                    }
+                },
+                previousSearchMatch: () => {
+                    if (this.viewerCanvas) {
+                        this.viewerCanvas.previousSearchMatch();
+                    }
+                },
+                endSearch: () => {
+                    if (this.viewerCanvas) {
+                        this.viewerCanvas.endSearch();
+                    }
+                },
+                updateCanvasSearchState: (state) => {
+                    if (this.viewerCanvas) {
+                        this.viewerCanvas.updateCanvasSearchState(state);
+                    }
+                },
+                goTo: (pdfDestination) => {
+                    if (this.viewerCanvas) {
+                        this.viewerCanvas.goTo(pdfDestination);
+                    }
+                },
+                goToAnnotation: (target) => {
+                    if (this.viewerCanvas) {
+                        if (target.annotation.isHidden()) {
+                            this.handleAnnotationSelected(target.annotation);
+                        }
+                        else {
+                            try {
+                                this.viewerCanvas.goToAnnotation(target.annotation, target.action);
+                            }
+                            catch (err) {
+                                console.error(err);
+                            }
+                        }
+                    }
+                },
+                resetViewerMode: (pdfDestination) => {
+                    if (this.viewerCanvas) {
+                        this.viewerCanvas.resetViewerMode();
+                    }
+                },
+                loadNavigationItems: () => {
+                    if (this.view) {
+                        this.loadPageThumbnails();
+                        this.loadAnnotations();
+                        const viewState = this.view.getState();
+                        if (!viewState.navigationPanel.outlineItemsLoaded) {
+                            this.loadDocumentOutlines();
+                        }
+                    }
+                },
+                addPageRangeToThumbnailsQueue: (pageRange) => {
+                    this.addPagesToThumbnailsQueue(pageRange.from, pageRange.to);
+                },
+                print: () => {
+                    if (this.viewerCanvas) {
+                        this.viewerCanvas.print();
+                    }
+                },
+                activateModule: (moduleName, args) => {
+                    if (this.viewerCanvas) {
+                        this.viewerCanvas.activateModule(moduleName, args);
+                    }
+                },
+                deactivateModule: (moduleName) => {
+                    if (this.viewerCanvas) {
+                        this.viewerCanvas.deactivateModule(moduleName);
+                    }
+                },
+            };
+            a.initialize();
+            return nextApp(state, a, view, element);
+        };
+    }
+    getScreenSize() {
+        var _a;
+        const widthToScreenSize = (width) => {
+            if (width <= ScreenSize.Small) {
+                return ScreenSize.Small;
+            }
+            if (width <= ScreenSize.Medium) {
+                return ScreenSize.Medium;
+            }
+            return ScreenSize.Large;
+        };
+        const viewerElm = this.element.firstChild;
+        if (!this.view || !viewerElm) {
+            return widthToScreenSize(this.element.getBoundingClientRect().width);
+        }
+        if (viewerElm.offsetWidth && viewerElm.offsetHeight && viewerElm.getClientRects().length) {
+            return widthToScreenSize(viewerElm.getBoundingClientRect().width);
+        }
+        return (_a = this.view) === null || _a === void 0 ? void 0 : _a.getState().layout.screenSize;
+    }
+    handleResize() {
+        if (this.view) {
+            const screenSize = this.getScreenSize();
+            if (this.view.getState().layout.screenSize !== screenSize) {
+                this.view.layout.setScreenSize(screenSize);
+            }
+        }
+    }
+    handleKeyboardShortcuts(e) {
+        var _a, _b, _c;
+        // check if element is visible
+        const rect = this.element.getBoundingClientRect();
+        if (rect.width + rect.height === 0) {
+            return;
+        }
+        const { shortcuts } = this.options;
+        if (Object.keys(shortcuts).length > 0) {
+            const keyboardCommands = getKeyboardCommands(e, shortcuts);
+            if (!keyboardCommands.length) {
+                return;
+            }
+            keyboardCommands.forEach((cmd) => {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+                switch (cmd[0]) {
+                    case 'save': {
+                        const { allowSaveFile } = this.options.viewer.permissions;
+                        if (allowSaveFile) {
+                            e.preventDefault();
+                            if (this.options.viewer.callbacks.onSaveFileButtonClicked) {
+                                this.options.viewer.onSaveFileButtonClicked();
+                            }
+                            else {
+                                this.downloadFile();
+                            }
+                        }
+                        break;
+                    }
+                    case 'print': {
+                        const { allowPrinting } = this.options.viewer.permissions;
+                        if (allowPrinting) {
+                            e.preventDefault();
+                            (_a = this.viewerCanvas) === null || _a === void 0 ? void 0 : _a.print();
+                        }
+                        break;
+                    }
+                    case 'cancelPrint': {
+                        const { allowPrinting } = this.options.viewer.permissions;
+                        if (allowPrinting) {
+                            (_b = this.viewerCanvas) === null || _b === void 0 ? void 0 : _b.deactivateModule('PrintServiceModule');
+                        }
+                        break;
+                    }
+                    case 'search': {
+                        const { enableSearch } = this.options.viewer.permissions;
+                        if (enableSearch) {
+                            e.preventDefault();
+                            (_c = this.view) === null || _c === void 0 ? void 0 : _c.search.openSearch();
+                        }
+                        break;
+                    }
+                    case 'searchNext': {
+                        const { enableSearch } = this.options.viewer.permissions;
+                        if (enableSearch) {
+                            const state = (_d = this.view) === null || _d === void 0 ? void 0 : _d.getState();
+                            if (state && state.search && state.search.showSearch && state.search.searchString) {
+                                (_e = this.viewerCanvas) === null || _e === void 0 ? void 0 : _e.nextSearchMatch();
+                            }
+                            e.preventDefault();
+                        }
+                        break;
+                    }
+                    case 'searchPrevious': {
+                        const { enableSearch } = this.options.viewer.permissions;
+                        if (enableSearch) {
+                            const state = (_f = this.view) === null || _f === void 0 ? void 0 : _f.getState();
+                            if (state && state.search && state.search.showSearch && state.search.searchString) {
+                                (_g = this.viewerCanvas) === null || _g === void 0 ? void 0 : _g.previousSearchMatch();
+                            }
+                            e.preventDefault();
+                        }
+                        break;
+                    }
+                    case 'closeSearch': {
+                        const { enableSearch } = this.options.viewer.permissions;
+                        if (enableSearch) {
+                            e.preventDefault();
+                            (_h = this.viewerCanvas) === null || _h === void 0 ? void 0 : _h.endSearch();
+                            (_j = this.view) === null || _j === void 0 ? void 0 : _j.search.closeSearch();
+                        }
+                        break;
+                    }
+                    case 'toggleSidePane': {
+                        const { sidebar } = this.options.viewer;
+                        if (sidebar.annotationNavigation ||
+                            sidebar.outlineNavigation ||
+                            sidebar.annotationNavigation) {
+                            e.preventDefault();
+                            (_k = this.view) === null || _k === void 0 ? void 0 : _k.navigationPanel.toggleNavigationPanel();
+                        }
+                        break;
+                    }
+                    case 'showAnnotations': {
+                        const { sidebar } = this.options.viewer;
+                        if (sidebar.annotationNavigation) {
+                            e.preventDefault();
+                            (_l = this.view) === null || _l === void 0 ? void 0 : _l.navigationPanel.selectNavigation('annotation');
+                        }
+                        break;
+                    }
+                    case 'showOutline': {
+                        const { sidebar } = this.options.viewer;
+                        if (sidebar.outlineNavigation) {
+                            e.preventDefault();
+                            (_m = this.view) === null || _m === void 0 ? void 0 : _m.navigationPanel.selectNavigation('outline');
+                        }
+                        break;
+                    }
+                    case 'showThumbnails': {
+                        const { sidebar } = this.options.viewer;
+                        if (sidebar.thumbnailNavigation) {
+                            e.preventDefault();
+                            (_o = this.view) === null || _o === void 0 ? void 0 : _o.navigationPanel.selectNavigation('thumbnail');
+                        }
+                        break;
+                    }
+                }
+            });
+        }
+        else if (e.key === 'Escape') {
+            (_a = this.viewerCanvas) === null || _a === void 0 ? void 0 : _a.deactivateModule('PrintServiceModule');
+            (_b = this.viewerCanvas) === null || _b === void 0 ? void 0 : _b.endSearch();
+            (_c = this.view) === null || _c === void 0 ? void 0 : _c.search.closeSearch();
+        }
+    }
+    showUnconfirmedChangesDialog() {
+        if (this.view && this.viewerCanvas) {
+            const currentState = this.view.getState();
+            const hasChanges = this.viewerCanvas.hasChanges();
+            return (!currentState.unsavedChangesDialogDontSave &&
+                currentState.hasDocument &&
+                hasChanges &&
+                this.options.viewer.general.promptOnUnsavedChange &&
+                this.options.viewer.permissions.allowSaveFile);
+        }
+    }
+    beforeOpen(args) {
+        if (this.view && this.viewerCanvas) {
+            if (this.showUnconfirmedChangesDialog()) {
+                this.view.showConfirmUnsavedChangesDialog(args);
+                return false;
+            }
+            this.view.navigationPanel.clear();
+            this.view.loadDocumentBegin();
+            return true;
+        }
+    }
+    openResolve(fileOpenArgs) {
+        if (this.view && this.viewerCanvas) {
+            this.view.pdfDocument.setFileInfo(fileOpenArgs.pdfFile);
+            this.view.pdfDocument.setHasChanges(false);
+            const pageCount = this.viewerCanvas.getPageCount();
+            this.view.pdfDocument.setPageCount(pageCount);
+            this.handleDocumentOpened();
+            this.view.loadDocumentFulfilled();
+            this.view.api.loadNavigationItems();
+            const inputFile = fileOpenArgs.pdfFile;
+            const eventArg = inputFile.uri
+                ? inputFile.uri
+                : new File([], inputFile.sourceTag, { type: 'application/pdf' });
+            this.dispatchEvent('documentLoaded', eventArg);
+        }
+    }
+    openReject(fileOpenArgs, error) {
+        if (this.view) {
+            if (error.message === 'password required') {
+                this.view.loadDocumentPasswordForm(fileOpenArgs);
+            }
+            else {
+                this.view.loadDocumentRejected(error.message);
+            }
+        }
+    }
+    handleDocumentOpened() {
+        if (this.view && this.viewerCanvas) {
+            const pageCount = this.viewerCanvas.getPageCount();
+            this.view.navigationPanel.setThumbnailPlaceholders(pageCount);
+            const viewerState = this.view.getState();
+            this.view.navigationPanel.clearAnnotations();
+            if (viewerState.navigationPanel.showNavigation) {
+                if (viewerState.navigationPanel.selectedNavigation === 'thumbnail') {
+                    this.loadPageThumbnails();
+                }
+                else if (viewerState.navigationPanel.selectedNavigation === 'outline') {
+                    this.loadDocumentOutlines();
+                }
+                else {
+                    this.loadAnnotations();
+                }
+            }
+        }
+    }
+    loadDocumentOutlines() {
+        if (this.viewerCanvas) {
+            this.viewerCanvas.getDocumentOutline().then((outlines) => {
+                if (this.view) {
+                    this.view.navigationPanel.setOutlines(outlines);
+                }
+            });
+        }
+    }
+    loadPageThumbnails() {
+        if (this.view && this.viewerCanvas) {
+            const state = this.view.getState();
+            const fromPage = state.pdfDocument.firstVisiblePage - 5;
+            const toPage = state.pdfDocument.lastVisiblePage + 5;
+            this.addPagesToThumbnailsQueue(fromPage, toPage);
+        }
+    }
+    addPagesToThumbnailsQueue(fromPage, toPage) {
+        if (this.view && this.viewerCanvas) {
+            const state = this.view.getState();
+            if (fromPage < 1) {
+                fromPage = 1;
+            }
+            if (toPage < fromPage) {
+                toPage = state.pdfDocument.firstVisiblePage + 5;
+            }
+            if (toPage > state.pdfDocument.pageCount) {
+                toPage = state.pdfDocument.pageCount;
+            }
+            const pagesToLoad = state.navigationPanel.pages
+                .filter((p) => p.pageNumber >= fromPage &&
+                p.pageNumber <= toPage &&
+                p.thumbnail === null &&
+                p.loading === null)
+                .map((p) => p.pageNumber);
+            pagesToLoad.forEach((p) => {
+                var _a;
+                if (this.loadThumbnailsQueue.indexOf(p) < 0) {
+                    (_a = this.view) === null || _a === void 0 ? void 0 : _a.navigationPanel.updateThumbnail({
+                        pageNumber: p,
+                        thumbnail: null,
+                        loading: true,
+                    });
+                    this.loadThumbnailsQueue.push(p);
+                }
+            });
+            const getPageThumbnail = (pageNumber) => {
+                this.updatePageThumbnail(pageNumber).then(() => {
+                    const nextPage = this.loadThumbnailsQueue.shift();
+                    if (nextPage) {
+                        getPageThumbnail(nextPage);
+                    }
+                }).catch(() => { });
+            };
+            const firstPage = this.loadThumbnailsQueue.shift();
+            if (firstPage) {
+                getPageThumbnail(firstPage);
+            }
+        }
+    }
+    updatePageThumbnail(pageNumber) {
+        return new Promise((resolve, reject) => {
+            if (this.view && this.viewerCanvas) {
+                this.viewerCanvas
+                    .renderPage(pageNumber, 200, 200)
+                    .then((thumbnail) => {
+                    var _a;
+                    const canvasElement = document.createElement('canvas');
+                    canvasElement.width = thumbnail.imageData.width;
+                    canvasElement.height = thumbnail.imageData.height;
+                    const ctx = canvasElement.getContext('2d');
+                    ctx && ctx.putImageData(thumbnail.imageData, 0, 0);
+                    const imageData = canvasElement.toDataURL('image/png');
+                    (_a = this.view) === null || _a === void 0 ? void 0 : _a.navigationPanel.updateThumbnail({
+                        pageNumber: thumbnail.page,
+                        thumbnail: imageData,
+                        loading: false,
+                    });
+                    resolve();
+                })
+                    .catch((error) => reject(error));
+            }
+            else {
+                reject();
+            }
+        });
+    }
+    loadAnnotations() {
+        if (!this.options.viewer.sidebar.annotationNavigation) {
+            return;
+        }
+        if (this.view) {
+            const state = this.view.getState();
+            if (state.navigationPanel.annotationsLoaded) {
+                return;
+            }
+            this.view.navigationPanel.initAnnotations(state.pdfDocument.pageCount);
+            const loadNext = (pages) => {
+                if (this.viewerCanvas) {
+                    const pageNumber = pages.shift();
+                    if (typeof pageNumber === 'number') {
+                        this.viewerCanvas
+                            .getAnnotationsFromPage(pageNumber)
+                            .then((itemsOnPage) => {
+                            var _a, _b;
+                            const selectableItems = itemsOnPage.items.filter((item) => { var _a; return (_a = item.behaviors) === null || _a === void 0 ? void 0 : _a.selectable; });
+                            if (selectableItems.length) {
+                                (_a = this.view) === null || _a === void 0 ? void 0 : _a.navigationPanel.setPageAnnotations({
+                                    page: itemsOnPage.page,
+                                    itemCategory: PdfItemCategory.ANNOTATION,
+                                    items: selectableItems,
+                                });
+                            }
+                            if (pages.length > 0) {
+                                loadNext(pages);
+                            }
+                            else {
+                                (_b = this.view) === null || _b === void 0 ? void 0 : _b.navigationPanel.setAnnotationLoaded();
+                            }
+                        });
+                    }
+                }
+            };
+            const pageCount = this.getPageCount() || 0;
+            const pageNumbers = [];
+            for (let i = 1; i <= pageCount; i++) {
+                pageNumbers.push(i);
+            }
+            loadNext(pageNumbers);
+        }
+    }
+    handleDocumentClosed() {
+        var _a, _b;
+        (_a = this.view) === null || _a === void 0 ? void 0 : _a.closeDocument();
+        (_b = this.viewerCanvas) === null || _b === void 0 ? void 0 : _b.close();
+        this.handleResize();
+        this.dispatchEvent('documentClosed', undefined);
+        return;
+    }
+    handleAppLoaded(loaded) {
+        if (this.view && this.viewerCanvas) {
+            this.view.initializeAppFulfilled({ licenseFeatures: this.viewerCanvas.licenseFeatures });
+            const canvasModules = this.viewerCanvas.getModules();
+            this.view.setCanvasModules(canvasModules);
+            this.dispatchEvent('appLoaded', loaded);
+        }
+    }
+    handleFirstVisiblePageChanged(page) {
+        if (this.view) {
+            this.visiblePageRange.firstPage = page;
+            this.updateVisiblePageRange();
+            this.view.pdfDocument.setFirstVisiblePage(page);
+        }
+    }
+    handleLastVisiblePageChanged(page) {
+        if (this.view) {
+            this.visiblePageRange.lastPage = page;
+            this.updateVisiblePageRange();
+            this.view.pdfDocument.setLastVisiblePage(page);
+        }
+    }
+    handlePageNumberChanged(page) {
+        if (this.view) {
+            this.view.pdfDocument.setPageNumber(page);
+            const { navigationPanel } = this.view.getState();
+            if (navigationPanel.showNavigation && navigationPanel.selectedNavigation === 'thumbnail') {
+                const elm = this.element.querySelector(`#pwv-thumbnail-navigation-page_${page}`);
+                const container = this.element.querySelector('.pwv-NavigationPanel__Content');
+                if (elm && container) {
+                    const containerBoundingRect = container.getBoundingClientRect();
+                    const pageBoundingRect = elm.getBoundingClientRect();
+                    if (pageBoundingRect.top < containerBoundingRect.top ||
+                        pageBoundingRect.bottom > containerBoundingRect.bottom) {
+                        elm.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
+                    }
+                }
+            }
+            this.dispatchEvent('pageNumberChanged', page);
+        }
+    }
+    updateVisiblePageRange() {
+        if (this.view) {
+            const state = this.view.getState();
+            if (state.navigationPanel.showNavigation &&
+                state.navigationPanel.selectedNavigation === 'thumbnail') {
+                if (this.loadPageThumbnailsTimer) {
+                    window.clearTimeout(this.loadPageThumbnailsTimer);
+                }
+                this.loadPageThumbnailsTimer = window.setTimeout(() => {
+                    this.loadPageThumbnailsTimer = null;
+                    this.loadPageThumbnails();
+                }, 100);
+            }
+        }
+    }
+    handleZoomChanged(zoom) {
+        if (this.view) {
+            this.view.pdfDocument.setZoom(zoom * 100);
+            this.dispatchEvent('zoomChanged', zoom);
+        }
+    }
+    handleFitModeChanged(fitMode) {
+        if (this.view) {
+            this.view.pdfDocument.setFitMode(fitMode);
+        }
+        this.dispatchEvent('fitModeChanged', fitMode);
+    }
+    handlePageLayoutModeChanged(layoutMode) {
+        if (this.view) {
+            this.view.pdfDocument.setPageLayoutMode(layoutMode);
+        }
+        this.dispatchEvent('pageLayoutModeChanged', layoutMode);
+    }
+    handleRotationChanged(rotation) {
+        this.dispatchEvent('rotationChanged', rotation);
+    }
+    handleBusyStateChanged(state) {
+        this.dispatchEvent('busyState', state);
+    }
+    handleAnnotationSelected(item) {
+        if (this.view) {
+            const annotation = item;
+            this.view.navigationPanel.selectAnnotation(annotation);
+            const { navigationPanel } = this.view.getState();
+            if (navigationPanel.showNavigation && navigationPanel.selectedNavigation === 'annotation') {
+                const elm = this.element.querySelector(`#pwv-annotation-navigation-item-${annotation.id}`);
+                if (elm) {
+                    elm.scrollIntoView({ behavior: 'smooth' });
+                }
+            }
+        }
+    }
+    handleAnnotationDeselected(item) {
+        if (this.view) {
+            this.view.navigationPanel.deselectAnnotation();
+        }
+    }
+    handleAnnotationCreated(item) {
+        if (this.view) {
+            const annotation = item;
+            this.view.navigationPanel.updateAnnotation(annotation);
+            const { navigationPanel } = this.view.getState();
+            if (navigationPanel.showNavigation && navigationPanel.selectedNavigation === 'annotation') {
+                window.setTimeout(() => {
+                    const elm = this.element.querySelector(`#pwv-annotation-navigation-item-${annotation.id}`);
+                    if (elm) {
+                        elm.scrollIntoView({ behavior: 'smooth' });
+                    }
+                }, 10);
+            }
+        }
+    }
+    handleAnnotationUpdated(item) {
+        if (this.view) {
+            const annotation = item;
+            this.view.navigationPanel.updateAnnotation(annotation);
+        }
+    }
+    handleAnnotationDeleted(deletedItem) {
+        if (this.view) {
+            this.view.navigationPanel.deleteAnnotation(deletedItem);
+        }
+    }
+    handlePageChanged(pageNumber) {
+        // the list is 0 index based. E.g. page 1 is at index 0
+        if (this.view) {
+            const pageNavigationItem = this.view.getState().navigationPanel.pages[pageNumber - 1];
+            if (pageNavigationItem && pageNavigationItem.thumbnail !== null) {
+                this.updatePageThumbnail(pageNumber);
+            }
+            this.dispatchEvent('documentChanged', undefined);
+        }
+    }
+    handleTextSelected(text) {
+        this.dispatchEvent('textSelected', text);
+    }
+    verifyOptions(clientOptions, defaultOptions) {
+        // Verify annotation Color options
+        if (clientOptions.annotation && clientOptions.annotation.colors) {
+            Object.keys(OptionsToVerify).forEach((k) => {
+                if (clientOptions.annotation && clientOptions.annotation.colors[k]) {
+                    if (!this.isContainedInArray(clientOptions.annotation.colors[k], defaultOptions.annotation.colors[OptionsToVerify[k]])) {
+                        throw new Error(`Invalid ${k}: ${defaultOptions.annotation.colors[k]} has not been found in ${OptionsToVerify[k]}.\n` +
+                            `Valid values are: ${defaultOptions.annotation.colors[OptionsToVerify[k]]}`);
+                    }
+                }
+            });
+            Object.keys(ColorPaletteMap).forEach((k) => {
+                if (clientOptions.annotation &&
+                    clientOptions.annotation.colors[k] &&
+                    !clientOptions.annotation.colors[ColorPaletteMap[k]]) {
+                    throw new Error(`Cannot set ${k} without setting ${ColorPaletteMap[k]}. Preset ${ColorPaletteMap[k]} might not be in ${k}`);
+                }
+            });
+        }
+    }
+    isContainedInArray(item, list) {
+        if (!list.find((el) => el === item)) {
+            return false;
+        }
+        return true;
+    }
+    handleError(error) {
+        if (this.view) {
+            this.view.setError(error.message);
+        }
+        this.dispatchEvent('error', error);
+    }
+}