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

package/es6/pdf-viewer-canvas/PdfViewerCanvas.js

@@ -0,0 +1,1226 @@
+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());
+    });
+};
+import { createStore } from './state/store';
+import { PdfViewerApi, PdfFitMode, PdfItemCategory, FileType, DocumentChange, } from '../pdf-viewer-api';
+import { translationManager } from '../common/TranslationManager';
+import { tooltipManager } from '../common/TooltipManager';
+import { CanvasEvents } from './CanvasEvents';
+import { StampAnnotationModule } from '../modules/stamp-annotation/StampAnnotationModule';
+import { PdfDocumentLayer } from './view-layers/PdfDocumentLayer';
+import { ScrollLayer } from './view-layers/ScrollLayer';
+import { BusyStateLayer } from './view-layers/BusyStateLayer';
+import { AnnotationSelectionLayer } from './view-layers/AnnotationSelectionLayer';
+import { TextSelectionLayer } from './view-layers/TextSelectionLayer';
+import { ViewerMode, CursorStyle, copyTextToClipboard } from './state/viewer';
+import { imageDataUrlToUint8Array } from '../common/Tools';
+import { PdfViewing } from '../pdf-viewing/PdfViewing';
+import { getKeyboardCommands } from '../common/utils';
+import { PopupModule } from '../modules';
+export class PdfViewerCanvas {
+    get licenseFeatures() {
+        const licenseFeatures = this.pdfViewerApi.getSupportedFeatures();
+        return {
+            annotate: !this.options.viewer.general.viewOnly &&
+                PdfViewing.LicenseFeature.Annotate ===
+                    (licenseFeatures & PdfViewing.LicenseFeature.Annotate),
+            fillFormFields: !this.options.viewer.general.viewOnly &&
+                PdfViewing.LicenseFeature.FillFormFields ===
+                    (licenseFeatures & PdfViewing.LicenseFeature.FillFormFields),
+            pageRotation: !this.options.viewer.general.viewOnly &&
+                PdfViewing.LicenseFeature.PageRotation ===
+                    (licenseFeatures & PdfViewing.LicenseFeature.PageRotation),
+        };
+    }
+    constructor(containerElement, license, options) {
+        var _a;
+        this.eventListeners = new Map();
+        this.documentLoaded = false;
+        this.renderLoopRunning = false;
+        if (!containerElement) {
+            throw { error: 'PdfViewerCanvas container element is null' };
+        }
+        this.options = options;
+        this.annotTimer = 0;
+        // bind events
+        this.onResize = this.onResize.bind(this);
+        this.startRenderLoop = this.startRenderLoop.bind(this);
+        this.updateViewLayerContext = this.updateViewLayerContext.bind(this);
+        this.onKeyboardShortcuts = this.onKeyboardShortcuts.bind(this);
+        this.dispatchEvent = this.dispatchEvent.bind(this);
+        this.onCanvasPointerDown = this.onCanvasPointerDown.bind(this);
+        this.onCanvasPointerMove = this.onCanvasPointerMove.bind(this);
+        this.onCanvasPointerUp = this.onCanvasPointerUp.bind(this);
+        this.onCanvasPointerClick = this.onCanvasPointerClick.bind(this);
+        this.onCanvasPointerDblClick = this.onCanvasPointerDblClick.bind(this);
+        this.onCanvasPointerLongPress = this.onCanvasPointerLongPress.bind(this);
+        this.onCanvasPointerStartDrag = this.onCanvasPointerStartDrag.bind(this);
+        this.onCanvasPointerEndDrag = this.onCanvasPointerEndDrag.bind(this);
+        this.onCanvasPointerPinch = this.onCanvasPointerPinch.bind(this);
+        this.onMouseWheel = this.onMouseWheel.bind(this);
+        this.onDocumentOpened = this.onDocumentOpened.bind(this);
+        this.onDocumentClosed = this.onDocumentClosed.bind(this);
+        this.onCanvasInvalidated = this.onCanvasInvalidated.bind(this);
+        this.onFirstVisiblePageChanged = this.onFirstVisiblePageChanged.bind(this);
+        this.onLastVisiblePageChanged = this.onLastVisiblePageChanged.bind(this);
+        this.onPageNumberChanged = this.onPageNumberChanged.bind(this);
+        this.onZoomChanged = this.onZoomChanged.bind(this);
+        this.onFitModeChanged = this.onFitModeChanged.bind(this);
+        this.onPageLayoutModeChanged = this.onPageLayoutModeChanged.bind(this);
+        this.onBusyStateChanged = this.onBusyStateChanged.bind(this);
+        this.onRotationChanged = this.onRotationChanged.bind(this);
+        this.onItemCreated = this.onItemCreated.bind(this);
+        this.onItemUpdated = this.onItemUpdated.bind(this);
+        this.onItemDeleted = this.onItemDeleted.bind(this);
+        this.onPageChanged = this.onPageChanged.bind(this);
+        this.onTextSelected = this.onTextSelected.bind(this);
+        this.onHtmlDocumentSelectionChanged = this.onHtmlDocumentSelectionChanged.bind(this);
+        this.onApiError = this.onApiError.bind(this);
+        this.beforeUnloadCallback = this.beforeUnloadCallback.bind(this);
+        this.getAnnotations = this.getAnnotations.bind(this);
+        this.openRoutine = this.openRoutine.bind(this);
+        this.print = this.print.bind(this);
+        this.close = this.close.bind(this);
+        this.searchIterator = null;
+        // create store
+        this.store = createStore();
+        // create api
+        const pdfViewerApiOptions = {
+            onlyAuthorCanEdit: (_a = options.annotation.onlyAuthorCanEdit) !== null && _a !== void 0 ? _a : false,
+            viewOnly: options.viewer.general.viewOnly,
+            user: options.viewer.general.user,
+            allowPopups: options.modules.includes(PopupModule),
+            annotationPermissionCallback: options.annotation.annotationPermissionCallback,
+        };
+        this.pdfViewerApi = new PdfViewerApi(pdfViewerApiOptions);
+        const licenseIsValid = this.pdfViewerApi.setLicenseKey(license);
+        if (!licenseIsValid) {
+            throw new Error('Invalid License');
+        }
+        // create elements
+        this.element = containerElement;
+        this.element.classList.add('pwv-ViewerCanvas');
+        const viewerContainer = document.createElement('div');
+        viewerContainer.classList.add('pwv-canvas-container');
+        this.element.appendChild(viewerContainer);
+        this.toolbarElement = document.createElement('div');
+        if (this.licenseFeatures.annotate) {
+            this.toolbarElement.classList.add('pwv-canvas-toolbar');
+            viewerContainer.appendChild(this.toolbarElement);
+        }
+        const canvasLayers = document.createElement('div');
+        canvasLayers.classList.add('pwv-canvas-layers');
+        viewerContainer.appendChild(canvasLayers);
+        this.viewLayersElement = document.createElement('div');
+        canvasLayers.appendChild(this.viewLayersElement);
+        viewerContainer.appendChild(canvasLayers);
+        this.viewLayers = [];
+        this.modules = [];
+        // events
+        this.resizeObserver = new ResizeObserver(this.onResize);
+        this.resizeObserver.observe(canvasLayers);
+        this.pdfViewerApi.addEventListener('firstVisiblePage', this.onFirstVisiblePageChanged);
+        this.pdfViewerApi.addEventListener('lastVisiblePage', this.onLastVisiblePageChanged);
+        this.pdfViewerApi.addEventListener('pageNumber', this.onPageNumberChanged);
+        this.pdfViewerApi.addEventListener('zoom', this.onZoomChanged);
+        this.pdfViewerApi.addEventListener('fitMode', this.onFitModeChanged);
+        this.pdfViewerApi.addEventListener('pageLayoutMode', this.onPageLayoutModeChanged);
+        this.pdfViewerApi.addEventListener('busyState', this.onBusyStateChanged);
+        this.pdfViewerApi.addEventListener('canvasInvalidated', this.onCanvasInvalidated);
+        this.pdfViewerApi.addEventListener('itemCreated', this.onItemCreated);
+        this.pdfViewerApi.addEventListener('itemUpdated', this.onItemUpdated);
+        this.pdfViewerApi.addEventListener('itemDeleted', this.onItemDeleted);
+        this.pdfViewerApi.addEventListener('pageChanged', this.onPageChanged);
+        this.pdfViewerApi.addEventListener('rotation', this.onRotationChanged);
+        this.pdfViewerApi.addEventListener('error', this.onApiError);
+        if (this.options.viewer.general.promptOnUnsavedChange) {
+            window.addEventListener('beforeunload', this.beforeUnloadCallback);
+        }
+        document.addEventListener('selectionchange', this.onHtmlDocumentSelectionChanged);
+        this.canvasEvents = new CanvasEvents(canvasLayers);
+        this.canvasEvents.suspend();
+        this.canvasEvents.addEventListener('pointerdown', this.onCanvasPointerDown);
+        this.canvasEvents.addEventListener('pointermove', this.onCanvasPointerMove);
+        this.canvasEvents.addEventListener('pointerup', this.onCanvasPointerUp);
+        this.canvasEvents.addEventListener('pointerclick', this.onCanvasPointerClick);
+        this.canvasEvents.addEventListener('pointerdblclick', this.onCanvasPointerDblClick);
+        this.canvasEvents.addEventListener('pointerlongpress', this.onCanvasPointerLongPress);
+        this.canvasEvents.addEventListener('pointerstartdrag', this.onCanvasPointerStartDrag);
+        this.canvasEvents.addEventListener('pointerenddrag', this.onCanvasPointerEndDrag);
+        this.canvasEvents.addEventListener('pinch', this.onCanvasPointerPinch);
+        this.viewLayersElement.addEventListener('wheel', this.onMouseWheel, {
+            passive: false,
+        });
+        document.addEventListener('keydown', this.onKeyboardShortcuts, {
+            passive: false,
+        });
+        translationManager.loadTranslations(this.options.viewer.general.language || 'en');
+        tooltipManager.setType(this.options.viewer.general.tooltips || 'title');
+        if (this.options.modules) {
+            // load pdf for stamps
+            if (this.licenseFeatures.annotate &&
+                this.options.modules.find((m) => m === StampAnnotationModule) &&
+                this.options.annotation.options.pdfStampFiles) {
+                this.registerPdfStamps(this.options.annotation.options.pdfStampFiles);
+            }
+        }
+        // Push the dispatching of the appLoaded event to the macro task queue
+        // otherwise any function added to the appLoaded event won't be notified
+        // since the event has already been dispatched
+        requestAnimationFrame(() => {
+            this.dispatchEvent('appLoaded', true);
+        });
+    }
+    open(pdfFile, fdfFiles, password, viewOptions, renderOptions) {
+        const _viewOptions = viewOptions ? viewOptions : {};
+        const containerRect = this.viewLayersElement.getBoundingClientRect();
+        const viewportSize = {
+            width: containerRect.width,
+            height: containerRect.height,
+        };
+        return this.openRoutine(this.pdfViewerApi.open, pdfFile, fdfFiles, password, _viewOptions, renderOptions, viewportSize);
+    }
+    save(saveOptions) {
+        const promises = new Array();
+        for (let i = 0; i < this.modules.length; i++) {
+            promises.push(this.modules[i].onSave());
+        }
+        const savePromise = new Promise((resolve, reject) => {
+            Promise.all(promises).then(() => {
+                return this.pdfViewerApi
+                    .save(saveOptions)
+                    .then((buffer) => {
+                    resolve(buffer);
+                })
+                    .catch((err) => {
+                    reject(err);
+                });
+            });
+        });
+        return savePromise;
+    }
+    /**
+     * @deprecated Deprecated in Version 3.10. Use Open method instead.
+     */
+    openFDF(pdfBuffer, fdfBuffer, password) {
+        return this.open({ data: pdfBuffer }, [{ data: fdfBuffer }], password);
+    }
+    /**
+     * @deprecated Deprecated in Version 3.10. Use Open method instead.
+     */
+    openUri(pdfUri, password, pdfAuthorization) {
+        return this.open({ uri: pdfUri }, [], password);
+    }
+    /**
+     * @deprecated Deprecated in Version 3.10. Use Open method instead.
+     */
+    openFDFUri(pdfUri, fdfUri, password, pdfAuthorization, fdfAuthorization) {
+        return this.open({ uri: pdfUri }, [{ uri: pdfUri }], password);
+    }
+    /**
+     * @deprecated Deprecated in Version 3.10. Use Open method instead.
+     */
+    openBlob(blob, password) {
+        return this.open({ data: blob }, [], password);
+    }
+    /**
+     * @deprecated Deprecated in Version 3.10. Use Open method instead.
+     */
+    openFDFBlob(pdfBlob, fdfBlob, password) {
+        return this.open({ data: pdfBlob }, [{ data: fdfBlob }], password);
+    }
+    /**
+     * @deprecated Deprecated in Version 3.10. Use save method instead.
+     */
+    saveFile(asFdf) {
+        return new Promise((resolve, reject) => {
+            const saveOptions = {};
+            if (asFdf) {
+                saveOptions.fileType = FileType.Fdf;
+            }
+            this.save(saveOptions).then((blob) => {
+                blob.arrayBuffer().then((arrayBuffer) => {
+                    resolve(new Uint8Array(arrayBuffer));
+                });
+            });
+        });
+    }
+    close() {
+        this.unRegisterModules();
+        this.onDocumentClosed();
+        if (this.searchIterator) {
+            this.searchIterator.close();
+            this.searchIterator = null;
+        }
+        return this.pdfViewerApi.close();
+    }
+    destroy() {
+        this.stopRenderLoop();
+        if (this.searchIterator) {
+            this.searchIterator.close();
+        }
+        this.resizeObserver.disconnect();
+        if (this.annotTimer) {
+            window.clearTimeout(this.annotTimer);
+        }
+        // remove listeners
+        this.eventListeners.clear();
+        document.removeEventListener('keydown', this.onKeyboardShortcuts);
+        window.removeEventListener('beforeunload', this.beforeUnloadCallback);
+        this.pdfViewerApi.removeEventListener('firstVisiblePage', this.onFirstVisiblePageChanged);
+        this.pdfViewerApi.removeEventListener('lastVisiblePage', this.onLastVisiblePageChanged);
+        this.pdfViewerApi.removeEventListener('pageNumber', this.onPageNumberChanged);
+        this.pdfViewerApi.removeEventListener('zoom', this.onZoomChanged);
+        this.pdfViewerApi.removeEventListener('fitMode', this.onFitModeChanged);
+        this.pdfViewerApi.removeEventListener('pageLayoutMode', this.onPageLayoutModeChanged);
+        this.pdfViewerApi.removeEventListener('busyState', this.onBusyStateChanged);
+        this.pdfViewerApi.removeEventListener('canvasInvalidated', this.onCanvasInvalidated);
+        this.pdfViewerApi.removeEventListener('itemCreated', this.onItemCreated);
+        this.pdfViewerApi.removeEventListener('itemUpdated', this.onItemUpdated);
+        this.pdfViewerApi.removeEventListener('itemDeleted', this.onItemDeleted);
+        this.pdfViewerApi.removeEventListener('pageChanged', this.onPageChanged);
+        this.pdfViewerApi.removeEventListener('rotation', this.onRotationChanged);
+        this.pdfViewerApi.removeEventListener('error', this.onApiError);
+        this.canvasEvents.suspend();
+        this.canvasEvents.removeEventListener('pointerdown', this.onCanvasPointerDown);
+        this.canvasEvents.removeEventListener('pointermove', this.onCanvasPointerMove);
+        this.canvasEvents.removeEventListener('pointerup', this.onCanvasPointerUp);
+        this.canvasEvents.removeEventListener('pointerclick', this.onCanvasPointerClick);
+        this.canvasEvents.removeEventListener('pointerdblclick', this.onCanvasPointerDblClick);
+        this.canvasEvents.removeEventListener('pointerlongpress', this.onCanvasPointerLongPress);
+        this.canvasEvents.removeEventListener('pointerstartdrag', this.onCanvasPointerStartDrag);
+        this.canvasEvents.removeEventListener('pointerenddrag', this.onCanvasPointerEndDrag);
+        this.canvasEvents.removeEventListener('pinch', this.onCanvasPointerPinch);
+        this.viewLayersElement.removeEventListener('wheel', this.onMouseWheel);
+        this.pdfViewerApi.destroy();
+        this.viewLayers = [];
+        this.modules = [];
+        // remove all child elements
+        while (this.element.firstChild) {
+            this.element.removeChild(this.element.firstChild);
+        }
+    }
+    hasChanges() {
+        return this.pdfViewerApi.hasChanges();
+    }
+    getProductVersion() {
+        return PdfViewing.Sdk.version;
+    }
+    getZoom() {
+        return this.pdfViewerApi.getZoom();
+    }
+    setZoom(zoom, location) {
+        this.pdfViewerApi.setZoom(zoom, location);
+    }
+    zoomIn(location) {
+        const zoom = this.pdfViewerApi.getZoom();
+        this.pdfViewerApi.setZoom(this.getNextZoomInLevel(zoom), location);
+    }
+    zoomOut(location) {
+        const zoom = this.pdfViewerApi.getZoom();
+        this.pdfViewerApi.setZoom(this.getNextZoomOutLevel(zoom), location);
+    }
+    getPageCount() {
+        return this.pdfViewerApi.getPageCount();
+    }
+    getPageNumber() {
+        return this.pdfViewerApi.getPageNumber();
+    }
+    rotatePage(pageNumber, direction) {
+        const { textSelection, selectedAnnotationId, selectedModuleName } = this.store.getState().viewer;
+        if (textSelection) {
+            const textSelectionLayer = this.viewLayers.find((v) => v instanceof TextSelectionLayer);
+            if (textSelectionLayer) {
+                textSelectionLayer.clearSelection();
+            }
+        }
+        if (selectedAnnotationId) {
+            this.store.viewer.deselectAnnotation();
+        }
+        if (selectedModuleName) {
+            this.store.viewer.endModule(selectedModuleName);
+        }
+        return this.pdfViewerApi.rotatePage(pageNumber, direction);
+    }
+    setPageNumber(page) {
+        if (page < 1) {
+            page = 1;
+        }
+        else {
+            const pageCount = this.pdfViewerApi.getPageCount();
+            if (page > pageCount) {
+                page = pageCount;
+            }
+        }
+        this.pdfViewerApi.setPageNumber(page);
+    }
+    scrollDown(distance = 100) {
+        if (distance === 0) {
+            return;
+        }
+        const pos = this.pdfViewerApi.getScrollPosition();
+        pos.y += distance * window.devicePixelRatio;
+        this.pdfViewerApi.setScrollPosition(pos);
+    }
+    scrollUp(distance = 100) {
+        if (distance === 0) {
+            return;
+        }
+        const pos = this.pdfViewerApi.getScrollPosition();
+        pos.y -= distance * window.devicePixelRatio;
+        this.pdfViewerApi.setScrollPosition(pos);
+    }
+    scrollLeft(distance = 100) {
+        if (distance === 0) {
+            return;
+        }
+        const pos = this.pdfViewerApi.getScrollPosition();
+        pos.x -= distance * window.devicePixelRatio;
+        this.pdfViewerApi.setScrollPosition(pos);
+    }
+    scrollRight(distance = 100) {
+        if (distance === 0) {
+            return;
+        }
+        const pos = this.pdfViewerApi.getScrollPosition();
+        pos.x += distance * window.devicePixelRatio;
+        this.pdfViewerApi.setScrollPosition(pos);
+    }
+    scrollMove(distanceVertical = 0, distanceHorizontal = 0) {
+        if (distanceVertical === 0 && distanceHorizontal === 0) {
+            return;
+        }
+        const pos = this.pdfViewerApi.getScrollPosition();
+        pos.y += distanceVertical * window.devicePixelRatio;
+        pos.x += distanceHorizontal * window.devicePixelRatio;
+        this.pdfViewerApi.setScrollPosition(pos);
+    }
+    nextPage() {
+        const page = this.pdfViewerApi.getPageNumber();
+        const pageCount = this.pdfViewerApi.getPageCount();
+        if (page < pageCount) {
+            this.pdfViewerApi.setPageNumber(page + 1);
+        }
+    }
+    previousPage() {
+        const page = this.pdfViewerApi.getPageNumber();
+        if (page > 1) {
+            this.pdfViewerApi.setPageNumber(page - 1);
+        }
+    }
+    getFitMode() {
+        return this.pdfViewerApi.getFitMode();
+    }
+    setFitMode(fitMode) {
+        this.pdfViewerApi.setFitMode(fitMode);
+    }
+    getPageLayoutMode() {
+        return this.pdfViewerApi.getPageLayoutMode();
+    }
+    setPageLayoutMode(pageLayoutMode) {
+        this.pdfViewerApi.setPageLayoutMode(pageLayoutMode);
+    }
+    getRotation() {
+        return this.pdfViewerApi.getRotation();
+    }
+    setRotation(rotation) {
+        this.pdfViewerApi.setRotation(rotation);
+    }
+    renderPage(pageNumber, width, height) {
+        return this.pdfViewerApi.renderPage(pageNumber, width, height);
+    }
+    getDocumentOutline() {
+        return this.getOutlines(null);
+    }
+    goTo(pdfDestination) {
+        this.pdfViewerApi.goTo(pdfDestination);
+    }
+    updateCanvasSearchState(state) {
+        this.store.search.start({
+            caseSensitive: state.caseSensitive,
+            searchString: state.searchString,
+            reverse: false,
+            useRegex: state.useRegex,
+            wrapSearch: state.wrapSearch,
+        });
+    }
+    doSearch() {
+        const s = this.store.getState().search;
+        if (this.searchIterator &&
+            this.searchIterator.match instanceof PdfViewing.Pdf.Content.TextSelection) {
+            const list = this.searchIterator.match.textArea;
+            let page = 1;
+            const quadrilateralList = [];
+            for (let i = 0; i < list.size; i++) {
+                const quad = list.get(i);
+                if (quad.pageNumber > page) {
+                    page = quad.pageNumber;
+                }
+                quadrilateralList.push(quad);
+            }
+            this.store.search.updateMatch({
+                match: quadrilateralList,
+                page,
+            });
+            const q = list.get(0);
+            const { bottomLeft, bottomRight, topRight, topLeft, pageNumber } = q;
+            const x = Math.min(bottomLeft.x, bottomRight.x, topRight.x, topLeft.x);
+            const y = Math.min(bottomLeft.y, bottomRight.y, topRight.y, topLeft.y);
+            const padding = 10;
+            const rect = {
+                pdfX: x - padding,
+                pdfY: y - padding,
+                pdfW: Math.max(bottomLeft.x, bottomRight.x, topRight.x, topLeft.x) - x + 2 * padding,
+                pdfH: Math.max(bottomLeft.y, bottomRight.y, topRight.y, topLeft.y) - y + 2 * padding,
+                page: pageNumber,
+            };
+            this.pdfViewerApi.goToRectangle(rect);
+        }
+    }
+    startSearch(searchString, startPage, caseSensitive, wrapSearch, useRegex) {
+        if (this.searchIterator) {
+            this.endSearch();
+        }
+        this.searchIterator = this.pdfViewerApi.getSearchIterator(searchString, startPage, caseSensitive, wrapSearch, useRegex);
+        if (!this.searchIterator) {
+            return;
+        }
+        this.searchIterator.getNext().then((hasResult) => {
+            if (hasResult) {
+                this.doSearch();
+            }
+            else {
+                this.endSearch();
+            }
+        });
+    }
+    nextSearchMatch() {
+        if (this.searchIterator) {
+            this.searchIterator.getNext().then((hasResult) => {
+                if (hasResult) {
+                    this.doSearch();
+                }
+            });
+        }
+    }
+    previousSearchMatch() {
+        if (this.searchIterator) {
+            return this.searchIterator.getPrevious().then((hasResult) => {
+                if (hasResult) {
+                    this.doSearch();
+                }
+            });
+        }
+    }
+    endSearch() {
+        if (this.searchIterator) {
+            this.searchIterator.close();
+            this.searchIterator = null;
+            this.store.search.clear();
+        }
+    }
+    resetViewerMode() {
+        this.store.viewer.setDefaultMode();
+    }
+    getAnnotationsFromPage(page) {
+        return new Promise((resolve, reject) => {
+            this.pdfViewerApi
+                .getItemsFromPage(page, PdfItemCategory.ANNOTATION)
+                .then((items) => {
+                this.store.annotations.setPageAnnotations(items);
+                resolve(items);
+            })
+                .catch((err) => {
+                reject(err);
+            });
+        });
+    }
+    goToAnnotation(annotation, action) {
+        this.pdfViewerApi.goToRectangle(annotation.pdfRect);
+        if (action === 'select') {
+            this.dispatchEvent('itemSelected', annotation);
+        }
+    }
+    print() {
+        this.activateModule('PrintServiceModule', null);
+    }
+    getModules() {
+        return this.modules;
+    }
+    activateModule(moduleName, args) {
+        const module = this.modules.find((m) => {
+            return m.name == moduleName;
+        });
+        if (module) {
+            module.activate(args);
+            this.dispatchEvent('moduleActivated', moduleName);
+        }
+    }
+    deactivateModule(moduleName) {
+        this.dispatchEvent('moduleActivated', moduleName);
+        const module = this.modules.find((m) => {
+            return m.name == moduleName;
+        });
+        if (module) {
+            module.deactivate();
+        }
+    }
+    getSelectedText() {
+        const { textSelection, textSelectionType } = this.store.getState().viewer;
+        let text = undefined;
+        if (textSelection) {
+            const { startPoint, endPoint } = textSelection;
+            text =
+                textSelectionType === 'rectangular'
+                    ? this.pdfViewerApi.getTextForRectangularSelection(startPoint, endPoint)
+                    : this.pdfViewerApi.getText(startPoint, endPoint);
+        }
+        return text;
+    }
+    addEventListener(type, listener) {
+        if (this.eventListeners.has(type)) {
+            ;
+            this.eventListeners.get(type).push(listener);
+        }
+        else {
+            this.eventListeners.set(type, [listener]);
+        }
+    }
+    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);
+            }
+        }
+    }
+    suspendCanvasEvents() {
+        this.canvasEvents.suspend();
+    }
+    resumeCanvasEvents() {
+        this.canvasEvents.resume();
+    }
+    dispatchEvent(type, args) {
+        if (this.eventListeners.has(type)) {
+            const listeners = this.eventListeners.get(type);
+            listeners.forEach((listener) => listener(args));
+        }
+    }
+    getOutlines(parent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const outlineItems = yield this.pdfViewerApi.getOutlines(parent);
+            for (const item of outlineItems) {
+                if (item.hasDescendants) {
+                    const children = yield this.getOutlines(item);
+                    item.descendants = children;
+                }
+            }
+            return outlineItems;
+        });
+    }
+    openRoutine(openFunction, ...args) {
+        return new Promise((resolve, reject) => {
+            if (this.pdfViewerApi.isOpen()) {
+                this.close();
+            }
+            requestAnimationFrame(() => {
+                openFunction(...args)
+                    .then(() => {
+                    this.onDocumentOpened();
+                    resolve({});
+                })
+                    .catch((error) => {
+                    if (error.message === 'The authentication failed due to a wrong password.') {
+                        reject(new Error('password required'));
+                    }
+                    else {
+                        reject(new Error('unsupported file'));
+                    }
+                });
+            });
+        });
+    }
+    onDocumentOpened() {
+        this.registerModules();
+        this.documentLoaded = true;
+        this.element.classList.add('pwv-ViewerCanvas--documentLoaded');
+        this.dispatchEvent('pageLayoutMode', this.pdfViewerApi.getPageLayoutMode());
+        this.dispatchEvent('firstVisiblePage', this.pdfViewerApi.getFirstVisiblePage());
+        this.dispatchEvent('lastVisiblePage', this.pdfViewerApi.getLastVisiblePage());
+        this.dispatchEvent('pageNumber', this.pdfViewerApi.getPageNumber());
+        this.dispatchEvent('zoom', this.pdfViewerApi.getZoom());
+        // set canvas size
+        const containerRect = this.viewLayersElement.getBoundingClientRect();
+        this.store.canvas.resize({
+            cssWidth: containerRect.width,
+            cssHeight: containerRect.height,
+        });
+        this.startRenderLoop();
+        const document = this.store.getState().document;
+        window.setTimeout(() => {
+            this.canvasEvents.resume();
+            this.element.classList.add('pwv-ViewerCanvas--documentLoaded');
+        }, 100);
+    }
+    onDocumentClosed() {
+        this.canvasEvents.suspend();
+        this.documentLoaded = false;
+        this.element.classList.remove('pwv-ViewerCanvas--documentLoaded');
+        this.stopRenderLoop();
+        this.store.loadDefaultState();
+    }
+    startRenderLoop() {
+        const viewLayers = this.viewLayers;
+        const modules = this.modules;
+        const loop = (timestamp) => {
+            const state = this.store.getState();
+            if (this.renderLoopRunning) {
+                this.store.resetChangedState();
+                if (state.viewer.cursorStyleChanged) {
+                    this.viewLayersElement.style.cursor = state.viewer.cursorStyle;
+                }
+                for (let i = 0; i < viewLayers.length; i++) {
+                    const res = viewLayers[i].render(timestamp, state);
+                    if (res === false) {
+                        break;
+                    }
+                }
+                for (let i = 0; i < modules.length; i++) {
+                    modules[i].render(timestamp, state);
+                }
+                requestAnimationFrame(loop);
+            }
+        };
+        this.renderLoopRunning = true;
+        requestAnimationFrame(loop);
+    }
+    stopRenderLoop() {
+        this.renderLoopRunning = false;
+    }
+    registerPdfStamps(pdfStampFiles) {
+        const pdfStampConfigs = this.options.annotation.options.stamps.filter((s) => s.pdfStampFileName);
+        const pdfStampConfigMap = pdfStampConfigs.reduce(function (acc, obj) {
+            let key = obj.pdfStampFileName;
+            if (!acc[key]) {
+                acc[key] = 0;
+            }
+            ++acc[key];
+            return acc;
+        }, {});
+        const onStampCreated = (pdfStamp) => {
+            if (pdfStampConfigMap.hasOwnProperty(pdfStamp.pdfStampFileName)) {
+                const stamp = this.options.annotation.options.stamps.find((s) => s.pdfStampFileName === pdfStamp.pdfStampFileName && s.pageNumber === pdfStamp.pageNumber);
+                if (stamp) {
+                    stamp.thumbnail = pdfStamp.thumbnail;
+                    stamp.aspectRatio = pdfStamp.aspectRatio;
+                }
+            }
+            else {
+                this.options.annotation.options.stamps.push(pdfStamp);
+            }
+        };
+        pdfStampFiles.forEach((stampFile) => {
+            const data = imageDataUrlToUint8Array(stampFile.data);
+            const pdfStampFileName = stampFile.pdfStampFileName ? stampFile.pdfStampFileName : '';
+            this.pdfViewerApi.registerPdfStampFile(pdfStampFileName, data, onStampCreated);
+        });
+    }
+    registerModules() {
+        // view layers
+        const viewLayers = [
+            PdfDocumentLayer,
+            BusyStateLayer,
+            AnnotationSelectionLayer,
+            TextSelectionLayer,
+            ScrollLayer,
+        ];
+        viewLayers.forEach((viewLayerBaseClass) => {
+            const viewLayer = new viewLayerBaseClass();
+            viewLayer.register(this, this.dispatchEvent);
+            this.viewLayers.push(viewLayer);
+        });
+        const modules = this.options.modules.filter(({ moduleInfo }) => (!moduleInfo.requiredFeatures.annotate ||
+            (moduleInfo.requiredFeatures.annotate && this.licenseFeatures.annotate)) &&
+            (!moduleInfo.requiredFeatures.fillFormFields ||
+                (moduleInfo.requiredFeatures.fillFormFields && this.licenseFeatures.fillFormFields)));
+        if (modules) {
+            modules.forEach((module) => {
+                const m = new module();
+                this.modules.push(m);
+                // tmp const for this, used for rollup
+                const viewerCanvas = this;
+                const reg = m.register(this.viewLayersElement, this.store, this.pdfViewerApi, viewerCanvas, this.options);
+                if (reg.toolbar && this.toolbarElement) {
+                    this.toolbarElement.appendChild(reg.toolbar);
+                }
+                if (reg.contextbar) {
+                    this.store.viewer.addContextBarItem(reg.contextbar);
+                }
+            });
+        }
+        this.updateCanvasSize();
+    }
+    unRegisterModules() {
+        this.viewLayers = [];
+        this.store.viewer.clearContextBarItems();
+        this.toolbarElement.innerHTML = '';
+        this.viewLayersElement.innerHTML = '';
+        this.modules.splice(0, this.modules.length);
+    }
+    updateViewLayerContext() {
+        const pixelRatio = window.devicePixelRatio;
+        this.store.canvas.setPixelRatio(pixelRatio);
+        const rect = this.viewLayersElement.getBoundingClientRect();
+        const maxScroll = this.pdfViewerApi.getScrollMaxPosition();
+        const scrollPosition = this.pdfViewerApi.getScrollPosition();
+        const devicePixelsWidth = rect.width * pixelRatio + (maxScroll.x > 0 ? maxScroll.x : scrollPosition.x * 2);
+        const devicePixelsHeight = rect.height * pixelRatio + (maxScroll.y > 0 ? maxScroll.y : scrollPosition.y * 2);
+        const zoom = this.pdfViewerApi.getZoom();
+        this.store.document.resize({ zoom, devicePixelsHeight, devicePixelsWidth });
+        this.store.scroll.scrollChanged({
+            cssLeft: scrollPosition.x,
+            cssTop: scrollPosition.y,
+        });
+        const state = this.store.getState();
+        const pageRects = {};
+        for (let page = this.pdfViewerApi.getFirstVisiblePage(); page <= this.pdfViewerApi.getLastVisiblePage(); page++) {
+            pageRects[page] = this.pdfViewerApi.getPageScreenRect(page);
+        }
+        this.store.document.updatePageRects(pageRects);
+    }
+    onMouseWheel(e) {
+        if (e.deltaY !== 0) {
+            if (e.ctrlKey) {
+                e.preventDefault();
+                e.cancelBubble = true;
+                const containerRect = this.viewLayersElement.getBoundingClientRect();
+                const x = e.clientX - containerRect.left;
+                const y = e.clientY - containerRect.top;
+                if (e.deltaY < 0) {
+                    this.zoomIn({ x, y });
+                }
+                else {
+                    this.zoomOut({ x, y });
+                }
+            }
+            else if (e.shiftKey) {
+                e.preventDefault();
+                e.cancelBubble = true;
+                const distance = e.deltaY > 0 ? 100 : -100;
+                this.scrollRight(distance);
+            }
+            else {
+                e.preventDefault();
+                e.cancelBubble = true;
+                const distance = e.deltaY > 0 ? 100 : -100;
+                this.scrollDown(distance);
+            }
+        }
+        else if (e.deltaX > 0) {
+            this.scrollRight();
+        }
+        else if (e.deltaX < 0) {
+            this.scrollLeft();
+        }
+        else if (e.deltaZ < 0) {
+            this.zoomIn();
+        }
+        else if (e.deltaZ > 0) {
+            this.zoomOut();
+        }
+    }
+    transformPointer(e) {
+        const containerRect = this.viewLayersElement.getBoundingClientRect();
+        const x = e.clientX - containerRect.left;
+        const y = e.clientY - containerRect.top;
+        return {
+            cssX: x,
+            cssY: y,
+            isDown: e.buttons === 1,
+            type: e.type,
+        };
+    }
+    onCanvasPointerClick(e) {
+        const p = this.transformPointer(e);
+        this.store.pointer.update(p);
+        this.store.pointer.setAction('click');
+    }
+    onCanvasPointerDblClick(e) {
+        const p = this.transformPointer(e);
+        this.store.pointer.update(p);
+        this.store.pointer.setAction('dblclick');
+    }
+    onCanvasPointerLongPress(e) {
+        const p = this.transformPointer(e);
+        this.store.pointer.update(p);
+        this.store.pointer.setAction('longpress');
+    }
+    onCanvasPointerStartDrag(e) {
+        this.store.pointer.setAction('startdrag');
+    }
+    onCanvasPointerEndDrag(e) {
+        this.store.pointer.setAction('enddrag');
+    }
+    onCanvasPointerPinch(e) {
+        const containerRect = this.viewLayersElement.getBoundingClientRect();
+        const x = (e.clientX - containerRect.left) * devicePixelRatio;
+        const y = (e.clientY - containerRect.top) * devicePixelRatio;
+        const zoom = this.pdfViewerApi.getZoom();
+        const zoomDistance = (e.movementDistance / 200) * zoom;
+        let newZoom = zoom + zoomDistance;
+        const minZoomLevel = this.options.viewer.general.defaultZoomLevels[0];
+        const maxZoomLevel = this.options.viewer.general.defaultZoomLevels[this.options.viewer.general.defaultZoomLevels.length - 1];
+        if (newZoom < minZoomLevel) {
+            newZoom = minZoomLevel;
+        }
+        else if (newZoom > maxZoomLevel) {
+            newZoom = maxZoomLevel;
+        }
+        this.setZoom(newZoom, { x, y });
+    }
+    onCanvasPointerDown(e) {
+        const p = this.transformPointer(e);
+        this.store.pointer.update(p);
+        this.store.startPointer.update(p);
+    }
+    onCanvasPointerUp(e) {
+        const p = this.transformPointer(e);
+        this.store.pointer.update(p);
+    }
+    onCanvasPointerMove(e) {
+        if (e.buttons < 2) {
+            const p = this.transformPointer(e);
+            this.store.pointer.update(p);
+        }
+        else if (e.buttons === 4) {
+            this.scrollMove(e.movementY * -1, e.movementX * -1);
+            this.store.viewer.setCursorStyle(CursorStyle.GRABBING);
+        }
+    }
+    onKeyboardShortcuts(e) {
+        // check if element is visible
+        const rect = this.element.getBoundingClientRect();
+        if (rect.width + rect.height === 0) {
+            return;
+        }
+        let metaflag = false;
+        // metaKey is true if it is super/command key in this context
+        // although meta key is normally alt
+        if (e.metaKey) {
+            metaflag = true;
+        }
+        const { shortcuts } = this.options;
+        if (Object.keys(shortcuts).length > 0) {
+            const keyboardCommands = getKeyboardCommands(e, shortcuts);
+            if (!keyboardCommands.length) {
+                return;
+            }
+            for (const cmd of keyboardCommands) {
+                // deal with super / command key in a central place
+                // it is not a modifier, but it behaves like one
+                const isSuperKeyRequired = cmd[1];
+                if (isSuperKeyRequired && !metaflag) {
+                    continue;
+                }
+                switch (cmd[0]) {
+                    case 'zoomIn':
+                        e.preventDefault();
+                        this.zoomIn();
+                        break;
+                    case 'zoomOut':
+                        e.preventDefault();
+                        this.zoomOut();
+                        break;
+                    case 'nextPage':
+                        e.preventDefault();
+                        this.nextPage();
+                        break;
+                    case 'previousPage':
+                        e.preventDefault();
+                        this.previousPage();
+                        break;
+                    case 'scrollDown':
+                        e.preventDefault();
+                        this.scrollDown();
+                        break;
+                    case 'scrollUp':
+                        e.preventDefault();
+                        this.scrollUp();
+                        break;
+                    case 'scrollLeft':
+                        e.preventDefault();
+                        this.scrollLeft();
+                        break;
+                    case 'scrollRight':
+                        e.preventDefault();
+                        this.scrollRight();
+                        break;
+                    case 'firstPage':
+                        e.preventDefault();
+                        this.setPageNumber(1);
+                        break;
+                    case 'lastPage':
+                        e.preventDefault();
+                        this.setPageNumber(this.getPageCount());
+                        break;
+                    case 'releaseSelection':
+                        const viewerMode = this.store.getState().viewer.mode;
+                        if (viewerMode === ViewerMode.TEXT_SELECTED) {
+                            e.preventDefault();
+                            e.cancelBubble = true;
+                            this.store.viewer.setTextSelection({ selection: null, type: null });
+                            this.store.viewer.setTextSelectionState(null);
+                            break;
+                        }
+                        if (viewerMode === ViewerMode.ANNOTATION_SELECTED) {
+                            e.preventDefault();
+                            e.cancelBubble = true;
+                            this.store.viewer.deselectAnnotation();
+                            break;
+                        }
+                        break;
+                    case 'copy':
+                        if (this.options.viewer.permissions.allowCopyText) {
+                            const documentSelection = document.getSelection();
+                            // Copy needs to work outside the viewer too
+                            // None if inside the viewer: Caret|Range outside
+                            if ((documentSelection === null || documentSelection === void 0 ? void 0 : documentSelection.type) && ['Caret', 'Range'].includes(documentSelection === null || documentSelection === void 0 ? void 0 : documentSelection.type)) {
+                                return;
+                            }
+                            e.preventDefault();
+                            e.cancelBubble = true;
+                            copyTextToClipboard(this.getSelectedText() || '');
+                        }
+                        break;
+                    case 'copyMac':
+                        if (this.options.viewer.permissions.allowCopyText) {
+                            const documentSelection = document.getSelection();
+                            // Copy needs to work outside the viewer too
+                            // None if inside the viewer: Caret|Range outside
+                            if ((documentSelection === null || documentSelection === void 0 ? void 0 : documentSelection.type) && ['Caret', 'Range'].includes(documentSelection === null || documentSelection === void 0 ? void 0 : documentSelection.type)) {
+                                return;
+                            }
+                            e.preventDefault();
+                            e.cancelBubble = true;
+                            copyTextToClipboard(this.getSelectedText() || '');
+                        }
+                        break;
+                    case 'resetZoom':
+                        e.preventDefault();
+                        this.setZoom(1);
+                        break;
+                    case 'fitToPage':
+                        e.preventDefault();
+                        this.setFitMode(PdfFitMode.FIT_PAGE);
+                        break;
+                    case 'fitToWidth':
+                        e.preventDefault();
+                        this.setFitMode(PdfFitMode.FIT_WIDTH);
+                        break;
+                    case 'rotateView':
+                        if (this.options.viewer.permissions.allowRotateView) {
+                            e.preventDefault();
+                            const r = this.getRotation();
+                            const rotation = r >= 270 ? 0 : r + 90;
+                            this.setRotation(rotation);
+                        }
+                        break;
+                    case 'cancelEditAnnotation':
+                        const { selectedModuleName } = this.store.getState().viewer;
+                        if (selectedModuleName) {
+                            this.store.viewer.endModule(selectedModuleName);
+                            e.preventDefault();
+                            break;
+                        }
+                }
+            }
+        }
+        else if (e.key === 'Escape') {
+            const { selectedModuleName, mode } = this.store.getState().viewer;
+            if (selectedModuleName) {
+                this.store.viewer.endModule(selectedModuleName);
+            }
+            const viewerMode = mode;
+            if (viewerMode === ViewerMode.TEXT_SELECTED) {
+                this.store.viewer.setTextSelection({ selection: null, type: null });
+                this.store.viewer.setTextSelectionState(null);
+            }
+            if (viewerMode === ViewerMode.ANNOTATION_SELECTED) {
+                this.store.viewer.deselectAnnotation();
+            }
+        }
+    }
+    onResize(entries, observer) {
+        const containerRect = this.viewLayersElement.getBoundingClientRect();
+        if (containerRect.width === 0 || containerRect.height === 0) {
+            return;
+        }
+        this.updateCanvasSize();
+    }
+    onHtmlDocumentSelectionChanged() {
+        const documentSelection = document.getSelection();
+        if (documentSelection) {
+            const viewerMode = this.store.getState().viewer.mode;
+            if (viewerMode === ViewerMode.TEXT_SELECTED) {
+                this.store.viewer.setTextSelection({ selection: null, type: null });
+                this.store.viewer.setTextSelectionState(null);
+            }
+        }
+    }
+    updateCanvasSize() {
+        const containerRect = this.viewLayersElement.getBoundingClientRect();
+        const pixelRatio = window.devicePixelRatio;
+        this.viewLayers.forEach((viewLayer) => {
+            viewLayer.resize(containerRect.width, containerRect.height, pixelRatio);
+        });
+        this.modules.forEach((module) => {
+            module.resize(containerRect.width, containerRect.height);
+        });
+        this.store.canvas.resize({
+            cssWidth: containerRect.width,
+            cssHeight: containerRect.height,
+        });
+        this.store.canvas.setCanvasInvalidated(true);
+    }
+    onCanvasInvalidated() {
+        this.store.canvas.setCanvasInvalidated(true);
+        this.updateViewLayerContext();
+    }
+    onFirstVisiblePageChanged(page) {
+        this.store.document.fistVisiblePageChanged(page);
+        this.maybeGetAnnotations(this.store.getState().document.firstVisiblePage, this.store.getState().document.lastVisiblePage);
+        this.dispatchEvent('firstVisiblePage', page);
+    }
+    onPageNumberChanged(page) {
+        this.dispatchEvent('pageNumber', page);
+    }
+    onTextSelected() {
+        var _a;
+        this.dispatchEvent('textSelected', (_a = this.getSelectedText()) !== null && _a !== void 0 ? _a : '');
+    }
+    /**
+     * This function works with a timer. This avoids mass loading of annotation when scrolling
+     * through a large document. It only loads the annotations once the viewport is stable (visible
+     * pages didn't change for 100ms). If there is an active timer that will be cancelled.
+     * @param begin first page to get annotations from
+     * @param end last page to get annotations from
+     */
+    maybeGetAnnotations(begin, end) {
+        if (this.annotTimer) {
+            window.clearTimeout(this.annotTimer);
+        }
+        this.annotTimer = window.setTimeout(() => {
+            this.getAnnotations(begin, end);
+        }, 100);
+    }
+    getAnnotations(begin, end) {
+        for (let page = begin; page <= end; page++) {
+            if (this.store.getState().annotations.byPage[page] === undefined) {
+                this.pdfViewerApi
+                    .getItemsFromPage(page, PdfItemCategory.ANNOTATION)
+                    .then((itemsOnPage) => {
+                    this.store.annotations.setPageAnnotations(itemsOnPage);
+                })
+                    .catch((err) => {
+                    console.warn(err);
+                });
+            }
+        }
+    }
+    onLastVisiblePageChanged(page) {
+        this.store.document.lastVisiblePageChanged(page);
+        this.maybeGetAnnotations(this.store.getState().document.firstVisiblePage, this.store.getState().document.lastVisiblePage);
+        this.dispatchEvent('lastVisiblePage', page);
+    }
+    onZoomChanged(zoom) {
+        this.dispatchEvent('zoom', zoom);
+    }
+    onFitModeChanged(fitMode) {
+        this.store.document.fitModeChanged(fitMode);
+        this.dispatchEvent('fitMode', fitMode);
+    }
+    onPageLayoutModeChanged(layoutMode) {
+        this.store.document.pageLayoutModeChanged(layoutMode);
+        this.dispatchEvent('pageLayoutMode', layoutMode);
+    }
+    onBusyStateChanged(state) {
+        this.store.document.busyStateChanged(state);
+        if (state) {
+            this.element.classList.remove('pwv-ViewerCanvas--documentIdle');
+        }
+        else {
+            this.element.classList.add('pwv-ViewerCanvas--documentIdle');
+        }
+        this.dispatchEvent('busyState', state);
+    }
+    onRotationChanged(rotation) {
+        this.store.document.rotationChanged(rotation);
+        this.dispatchEvent('rotation', rotation);
+    }
+    onItemCreated(item) {
+        if (item.itemCategory === PdfItemCategory.ANNOTATION) {
+            this.store.annotations.addAnnotation(item);
+        }
+        this.dispatchEvent('itemCreated', item);
+    }
+    onItemUpdated(item) {
+        if (item.itemCategory === PdfItemCategory.ANNOTATION) {
+            this.store.annotations.updateAnnotation(item);
+        }
+        this.dispatchEvent('itemUpdated', item);
+    }
+    onItemDeleted(deletedItem) {
+        if (deletedItem.categoryType === PdfItemCategory.ANNOTATION) {
+            this.store.annotations.deleteAnnotation(deletedItem.id);
+        }
+        this.dispatchEvent('itemDeleted', deletedItem);
+    }
+    onPageChanged(pageNumber) {
+        this.pdfViewerApi
+            .getItemsFromPage(pageNumber, PdfItemCategory.ANNOTATION)
+            .then((itemsOnPage) => {
+            itemsOnPage.items.forEach((annotation) => {
+                this.store.annotations.updateAnnotation(annotation);
+            });
+            this.dispatchEvent('pageChanged', pageNumber);
+        });
+    }
+    onApiError(error) {
+        console.error('//// PdfViewerApi Error: ', error);
+        this.dispatchEvent('error', error);
+    }
+    beforeUnloadCallback(e) {
+        const changes = this.pdfViewerApi.hasChanges();
+        if (changes !== null && changes !== DocumentChange.NONE) {
+            e.preventDefault();
+            e.returnValue = '';
+        }
+        else {
+            return;
+        }
+    }
+    getNextZoomOutLevel(zoomCurrent) {
+        for (var i = this.options.viewer.general.defaultZoomLevels.length - 1; i >= 0; i--) {
+            if (zoomCurrent > this.options.viewer.general.defaultZoomLevels[i])
+                return this.options.viewer.general.defaultZoomLevels[i];
+        }
+        return this.options.viewer.general.defaultZoomLevels[0];
+    }
+    getNextZoomInLevel(zoomCurrent) {
+        for (var i = 0; i < this.options.viewer.general.defaultZoomLevels.length; i++) {
+            if (zoomCurrent < this.options.viewer.general.defaultZoomLevels[i])
+                return this.options.viewer.general.defaultZoomLevels[i];
+        }
+        return this.options.viewer.general.defaultZoomLevels[this.options.viewer.general.defaultZoomLevels.length - 1];
+    }
+}