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

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

@@ -0,0 +1,2037 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+import { PdfActionType, PdfFitMode, PdfItemCategory, PdfItemType, WidgetType, PdfPageLayoutMode, AnnotationBorderStyle, DocumentChange, RotationDirection, } from './enums';
+import { FileType, } from './types';
+import { annotationDefaultBehaviors } from './annotationDefaultBehaviors';
+import { PdfViewing } from '../pdf-viewing/PdfViewing';
+import { ImageContainer } from './ImageContainer';
+export class PdfViewingWrapper {
+    constructor(key, pdfViewerApiOptions) {
+        this.pdfDocument = null;
+        this.objectUrls = [];
+        this.view = null;
+        this.textFragmentCache = new Map();
+        this.nativeAnnotationCache = new Map();
+        this.handleAnnotationCache = new Map();
+        this.pageAnnotationCache = new Map();
+        this.imageBitmapCache = new Map();
+        this.ignoreDocumentPreferences = false;
+        this.nativeOutlines = new Map();
+        this.devicePixelRatio = window.devicePixelRatio;
+        this.xDPI = 0;
+        this.yDPI = 0;
+        PdfViewing.Sdk.initialize(key, PdfViewing.Sdk.version);
+        this.validateViewingSdkVersion();
+        this.pdfViewerApiOptions = pdfViewerApiOptions;
+        this.licenseFeatures = PdfViewing.Sdk.supportedFeatures;
+        this.pdfController = new PdfViewing.ViewerController();
+        this.eventListeners = new Map();
+        this.viewportSize = new PdfViewing.Pdf.Geometry.Real.Size(0, 0);
+        this.pdfStampDocuments = new Map();
+        this.registeredPdfStamps = new Map();
+        this.attachEventListeners = this.attachEventListeners.bind(this);
+        this.onDocumentOpened = this.onDocumentOpened.bind(this);
+        this.onViewUpdated = this.onViewUpdated.bind(this);
+        this.onImageCreated = this.onImageCreated.bind(this);
+        this.onImageRemovedFromCache = this.onImageRemovedFromCache.bind(this);
+        this.getAnnotationsFromPage = this.getAnnotationsFromPage.bind(this);
+    }
+    getIgnoringPreferences() {
+        return this.ignoreDocumentPreferences;
+    }
+    setIgnoringPreferences(ignorePreferences) {
+        this.ignoreDocumentPreferences = ignorePreferences;
+    }
+    open(pdfFile, fdfFiles, password, viewOptions, renderOptions, viewportSize) {
+        return new Promise((resolve, reject) => {
+            const mapInputDocument = (file, fileType) => {
+                try {
+                    let mimeType = 'application/pdf';
+                    switch (fileType) {
+                        case FileType.Fdf:
+                            mimeType = 'application/vnd.fdf';
+                            break;
+                        // case FileType.Xfdf:
+                        //  mimeType = 'application/vnd.adobe.xfdf'
+                        //   break
+                    }
+                    const { data } = file;
+                    let uri = '';
+                    let httpOptions = new PdfViewing.IO.HttpOptions();
+                    if (data) {
+                        uri = URL.createObjectURL(new File([data], pdfFile.sourceTag || '', {
+                            type: mimeType,
+                        }));
+                    }
+                    else {
+                        const inputUri = file;
+                        uri = inputUri.uri;
+                        if (inputUri.httpOptions) {
+                            const { headers, mode, cache, credentials, redirect, referrerPolicy } = inputUri.httpOptions;
+                            if (mode !== undefined ||
+                                cache !== undefined ||
+                                credentials !== undefined ||
+                                redirect !== undefined ||
+                                referrerPolicy !== undefined) {
+                                console.warn(`
+                You are using a property that has been deprecated for stability reasons on iOS. 
+                Affected properties are: mode, cache, credentials, redirect, referrerPolicy.
+                If you want to continue using one of these properties, please switch to the separate build that is now available at: https://pdftools-public-downloads-production.s3.eu-west-1.amazonaws.com/productkits/VIEWWEB/4.3.6/extended/pdf-tools-four-heights-pdf-web-viewer-4.3.6.tar.gz
+                You can read more about this in our docs: https://www.pdf-tools.com/public/downloads/manuals/PdfWebViewer.pdf
+              `);
+                            }
+                            if (headers) {
+                                // httpOptions.headers = new PdfViewing.StringMap()
+                                Object.keys(headers).forEach((key) => {
+                                    var _a;
+                                    (_a = httpOptions.headers) === null || _a === void 0 ? void 0 : _a.set(key, headers[key]);
+                                });
+                            }
+                            httpOptions.credentials = null;
+                            httpOptions.cache = null;
+                            httpOptions.mode = null;
+                            httpOptions.redirect = null;
+                            httpOptions.referrerPolicy = null;
+                        }
+                    }
+                    return new PdfViewing.IO.InputUri(uri, httpOptions, pdfFile.sourceTag);
+                }
+                catch (err) {
+                    throw new Error('failed to create InputDocument');
+                }
+            };
+            const pdfInputFile = mapInputDocument(pdfFile, FileType.Pdf);
+            const fdfInputFiles = new PdfViewing.IO.InputDocumentList();
+            if (fdfFiles && fdfFiles.length) {
+                fdfFiles.forEach((file) => {
+                    const fdfFile = mapInputDocument(file, FileType.Fdf);
+                    if (fdfFile) {
+                        fdfInputFiles.add(fdfFile);
+                    }
+                });
+            }
+            const mapViewOptions = (viewOptions) => {
+                try {
+                    if (!viewOptions) {
+                        return null;
+                    }
+                    const options = new PdfViewing.Pdf.ViewOptions();
+                    options.initialDestination = null;
+                    if (typeof viewOptions.initialFitMode === 'number') {
+                        options.initialFitMode = this.WwFitModeToViewingFitMode(viewOptions.initialFitMode);
+                    }
+                    if (typeof viewOptions.initialPageLayoutMode === 'number') {
+                        options.initialPageLayoutMode = this.WwPageLayoutToViewingPageLayout(viewOptions.initialPageLayoutMode);
+                    }
+                    if (typeof viewOptions.initialPageNumber === 'number' ||
+                        typeof viewOptions.initialZoom === 'number') {
+                        const pageNumber = typeof viewOptions.initialPageNumber === 'number' ? viewOptions.initialPageNumber : 1;
+                        const zoom = typeof viewOptions.initialZoom === 'number' ? viewOptions.initialZoom : null;
+                        options.initialDestination = new PdfViewing.Pdf.Navigation.LocationZoomDestination(pageNumber, null, null, zoom);
+                    }
+                    if (typeof viewportSize === 'object') {
+                        this.viewportSize = new PdfViewing.Pdf.Geometry.Integer.Size(viewportSize.width, viewportSize.height);
+                        options.viewportSize = this.viewportSize;
+                    }
+                    return options;
+                }
+                catch (err) {
+                    console.error(err);
+                    throw new Error('failed to create View Options');
+                }
+            };
+            const sdkViewOptions = mapViewOptions(viewOptions);
+            const mapRenderOptions = (renderOptions) => {
+                try {
+                    if (!renderOptions) {
+                        return null;
+                    }
+                    const options = new PdfViewing.Pdf.RenderOptions();
+                    if (renderOptions.formFieldHighlightColor) {
+                        options.formFieldHighlightColor = this.createNativeColor(renderOptions.formFieldHighlightColor);
+                    }
+                    if (renderOptions.formFieldRequiredHighlightColor) {
+                        options.formFieldRequiredHighlightColor = this.createNativeColor(renderOptions.formFieldRequiredHighlightColor);
+                    }
+                    // if (renderOptions.annotationFilter) {
+                    //   options.annotationFilter = this.createAnnotationFilter(renderOptions.annotationFilter)
+                    // }
+                    return options;
+                }
+                catch (err) {
+                    throw new Error('failed to create Render Options');
+                }
+            };
+            const sdkRenderOptions = mapRenderOptions(renderOptions);
+            this.pdfController
+                .open(pdfInputFile, fdfInputFiles, password)
+                .then((document) => {
+                this.pdfDocument = document;
+                this.onDocumentOpened(document, sdkRenderOptions, sdkViewOptions);
+                resolve();
+            })
+                .catch((error) => {
+                console.warn(error);
+                reject(error);
+            });
+        });
+    }
+    save(saveOptions) {
+        const { fileType, annotationFilter, password } = saveOptions || {};
+        const _saveOptions = new PdfViewing.Pdf.SaveOptions();
+        switch (fileType) {
+            case FileType.Fdf:
+                _saveOptions.fileType = PdfViewing.IO.FileType.Fdf;
+                break;
+            // case FileType.Xfdf:
+            //   type = PdfViewing.IO.FileType.Xfdf
+            //   break
+            default:
+                _saveOptions.fileType = PdfViewing.IO.FileType.Pdf;
+        }
+        _saveOptions.annotationFilter = annotationFilter
+            ? this.createAnnotationFilter(annotationFilter)
+            : null;
+        if (password) {
+            _saveOptions.password = password;
+        }
+        return new Promise((resolve, reject) => {
+            if (this.pdfDocument) {
+                this.pdfDocument
+                    .save(_saveOptions)
+                    .then((file) => {
+                    const buffer = file.bufferData;
+                    if (buffer) {
+                        const blob = new Blob([file.bufferData]);
+                        file.close();
+                        resolve(blob);
+                    }
+                    else {
+                        reject('Returned save buffer is null');
+                    }
+                })
+                    .catch((error) => {
+                    console.warn(error);
+                    reject(error);
+                });
+            }
+            else {
+                reject('No document opened');
+            }
+        });
+    }
+    close() {
+        var _a, _b;
+        this.nativeAnnotationCache.forEach((annot) => {
+            var _a;
+            if (annot instanceof PdfViewing.Pdf.Annotations.MarkupAnnotation) {
+                (_a = annot.info) === null || _a === void 0 ? void 0 : _a.close();
+            }
+            annot.close();
+        });
+        this.nativeAnnotationCache.clear();
+        this.handleAnnotationCache.clear();
+        this.pageAnnotationCache.clear();
+        this.textFragmentCache.clear();
+        this.objectUrls.forEach((url) => {
+            URL.revokeObjectURL(url);
+        });
+        this.objectUrls = [];
+        this.nativeOutlines.forEach((outline) => {
+            outline.close();
+        });
+        this.nativeOutlines.clear();
+        (_a = this.view) === null || _a === void 0 ? void 0 : _a.close();
+        (_b = this.pdfDocument) === null || _b === void 0 ? void 0 : _b.close();
+        this.pdfDocument = null;
+    }
+    destroy() {
+        if (this.view) {
+            this.view.removeEventListener('viewUpdated', this.onViewUpdated);
+            this.view.removeEventListener('imageCreated', this.onImageCreated);
+            this.view.removeEventListener('imageRemovedFromCache', this.onImageRemovedFromCache);
+        }
+        this.close();
+        this.pdfStampDocuments.forEach((stampDocument) => {
+            stampDocument.close();
+        });
+        this.pdfController.close();
+        this.imageBitmapCache.forEach((imageContainer) => {
+            imageContainer.destroy();
+        });
+        this.nativeOutlines.clear();
+        this.imageBitmapCache.clear();
+        this.textFragmentCache.clear();
+        this.nativeAnnotationCache.clear();
+        this.handleAnnotationCache.clear();
+        this.pageAnnotationCache.clear();
+        this.pdfStampDocuments.clear();
+        this.registeredPdfStamps.clear();
+    }
+    registerPdfStampFile(pdfStampFileName, data, onStampCreated) {
+        const url = URL.createObjectURL(new File([data], pdfStampFileName, { type: 'application/pdf' }));
+        this.objectUrls.push(url);
+        this.pdfController
+            .openUri(url, null, null, null, null)
+            .then((pdfDocument) => {
+            const createStamps = () => __awaiter(this, void 0, void 0, function* () {
+                var _a, e_1, _b, _c, _d, e_2, _e, _f;
+                const pageNumbers = Array.from({ length: pdfDocument.pageCount }, (_, i) => i + 1);
+                let maxHeight = 0;
+                let maxWidth = 0;
+                const stampSizes = {};
+                try {
+                    for (var _g = true, pageNumbers_1 = __asyncValues(pageNumbers), pageNumbers_1_1; pageNumbers_1_1 = yield pageNumbers_1.next(), _a = pageNumbers_1_1.done, !_a;) {
+                        _c = pageNumbers_1_1.value;
+                        _g = false;
+                        try {
+                            let pageNumber = _c;
+                            const size = yield pdfDocument.getPagePdfSize(pageNumber);
+                            stampSizes[pageNumber] = size;
+                            maxHeight = Math.max(size.height, maxHeight);
+                            maxWidth = Math.max(size.width, maxWidth);
+                        }
+                        finally {
+                            _g = true;
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_g && !_a && (_b = pageNumbers_1.return)) yield _b.call(pageNumbers_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                const MAX_PX_WIDTH = 200;
+                const MAX_PX_HEIGHT = 100;
+                const scale = Math.max(maxHeight / MAX_PX_HEIGHT, maxWidth / MAX_PX_WIDTH);
+                try {
+                    for (var _h = true, pageNumbers_2 = __asyncValues(pageNumbers), pageNumbers_2_1; pageNumbers_2_1 = yield pageNumbers_2.next(), _d = pageNumbers_2_1.done, !_d;) {
+                        _f = pageNumbers_2_1.value;
+                        _h = false;
+                        try {
+                            let pageNumber = _f;
+                            const size = stampSizes[pageNumber];
+                            const aspectRatio = size.width / size.height;
+                            const img = yield pdfDocument.renderPage(pageNumber, size.width / scale, size.height / scale, 0);
+                            const tempCanvas = document.createElement('canvas');
+                            tempCanvas.width = img.width;
+                            tempCanvas.height = img.height;
+                            const tempContext = tempCanvas.getContext('2d');
+                            const imgData = new ImageData(new Uint8ClampedArray(img.bufferView), img.width, img.height);
+                            tempContext.putImageData(imgData, 0, 0);
+                            const thumbnail = tempCanvas.toDataURL('png');
+                            onStampCreated({
+                                pdfStampFileName,
+                                name: `${pdfStampFileName} - ${pageNumber}`,
+                                pageNumber,
+                                thumbnail,
+                                aspectRatio,
+                            });
+                        }
+                        finally {
+                            _h = true;
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (!_h && !_d && (_e = pageNumbers_2.return)) yield _e.call(pageNumbers_2);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            });
+            this.pdfStampDocuments.set(pdfStampFileName, pdfDocument);
+            createStamps();
+        })
+            .catch((error) => {
+            console.warn(error);
+        });
+    }
+    getPageCount() {
+        if (this.pdfDocument) {
+            return this.pdfDocument.pageCount;
+        }
+        else {
+            return null;
+        }
+    }
+    registerImage(imageBuffer) {
+        return new Promise((resolve, reject) => {
+            if (this.pdfDocument) {
+                const imgBlob = URL.createObjectURL(new Blob([imageBuffer]));
+                this.pdfDocument.registerImageUri(imgBlob, null).then((id) => {
+                    resolve(id);
+                });
+            }
+        });
+    }
+    registerPdfPage(fileName, pageNumber) {
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            if (this.pdfDocument) {
+                const pdfDoc = this.pdfStampDocuments.get(fileName);
+                if (!pdfDoc) {
+                    resolve(0);
+                }
+                else {
+                    const registeredPdfStampsKey = `${fileName}__${pageNumber}`;
+                    const stampRefId = this.registeredPdfStamps.get(registeredPdfStampsKey);
+                    if (stampRefId) {
+                        resolve(stampRefId);
+                    }
+                    else {
+                        const id = yield this.pdfDocument.registerPdfPage(pdfDoc, pageNumber);
+                        this.registeredPdfStamps.set(registeredPdfStampsKey, id);
+                        resolve(id);
+                    }
+                }
+            }
+        }));
+    }
+    getPageNumber() {
+        if (this.view) {
+            return this.view.pageNumber;
+        }
+        return 0;
+    }
+    getFitMode() {
+        var _a;
+        var fitMode = (_a = this.view) === null || _a === void 0 ? void 0 : _a.fitMode;
+        if (fitMode === undefined) {
+            throw new Error('Invalid fit mode');
+        }
+        else {
+            return fitMode;
+        }
+    }
+    setFitMode(mode) {
+        if (this.view) {
+            this.view.fitMode = mode;
+        }
+    }
+    setPageNumber(page) {
+        if (this.view) {
+            this.view.pageNumber = page;
+        }
+    }
+    getZoom() {
+        if (this.view) {
+            return this.view.zoom;
+        }
+        return 0;
+    }
+    setZoom(zoom, location) {
+        if (this.view) {
+            if (location) {
+                const p = new PdfViewing.Pdf.Geometry.Integer.Point(location.x, location.y);
+                this.view.zoomOnLocation(zoom, p);
+            }
+            else {
+                this.view.zoom = zoom;
+            }
+        }
+    }
+    getRotation() {
+        if (this.view) {
+            return this.view.viewRotation;
+        }
+        return 0;
+    }
+    setRotation(rotation) {
+        if (this.view) {
+            this.view.viewRotation = rotation;
+        }
+    }
+    setBorderSize(size) {
+        if (this.view) {
+            this.view.borderSize = size;
+        }
+    }
+    getBorderSize() {
+        if (this.view) {
+            return this.view.borderSize;
+        }
+        return 0;
+    }
+    suspendDrawing() {
+        var _a;
+        (_a = this.view) === null || _a === void 0 ? void 0 : _a.suspendDrawing();
+    }
+    resumeDrawing() {
+        var _a;
+        (_a = this.view) === null || _a === void 0 ? void 0 : _a.resumeDrawing();
+    }
+    renderCanvas(ctx, options) {
+        var _a;
+        if (this.view) {
+            // viewport size changed?
+            if (this.viewportSize.width != ctx.canvas.width ||
+                this.viewportSize.height != ctx.canvas.height) {
+                this.viewportSize.width = ctx.canvas.width;
+                this.viewportSize.height = ctx.canvas.height;
+                this.view.viewportSize = new PdfViewing.Pdf.Geometry.Integer.Size(ctx.canvas.width, ctx.canvas.height);
+            }
+            const data = (_a = this.view) === null || _a === void 0 ? void 0 : _a.getRenderedResults();
+            if (data) {
+                this.drawImages(ctx, data, options);
+                data.close();
+            }
+        }
+    }
+    renderPage(page, width, height, annotationFilter) {
+        // TODO: expose rotation
+        let renderOptions = null;
+        if (annotationFilter) {
+            renderOptions = new PdfViewing.Pdf.RenderOptions();
+            renderOptions.annotationFilter = this.createAnnotationFilter(annotationFilter);
+        }
+        return new Promise((resolve, reject) => {
+            var _a;
+            (_a = this.pdfDocument) === null || _a === void 0 ? void 0 : _a.renderPage(page, width, height, /* rotation = */ 0, renderOptions).then((image) => {
+                const imgBuffer = image.bufferView;
+                if (!imgBuffer) {
+                    reject();
+                }
+                let pageImage = {};
+                pageImage.page = page;
+                pageImage.imageData = new ImageData(new Uint8ClampedArray(imgBuffer), image.width, image.height);
+                image.close();
+                resolve(pageImage);
+            }).catch((err) => {
+                if (err.message !== 'Document was closed before operation could finish') {
+                    reject(`failed to render page ${page}`);
+                }
+            });
+        });
+    }
+    rotatePage(pageNumber, direction) {
+        var _a;
+        const page = (_a = this.pdfDocument) === null || _a === void 0 ? void 0 : _a.pages.get(pageNumber - 1);
+        if (page) {
+            page.rotatePage(direction === RotationDirection.CLOCKWISE ? 90 : -90);
+            this.dispatchEvent('pageChanged', pageNumber);
+        }
+    }
+    getPagePdfSize(page) {
+        return new Promise((resolve, reject) => {
+            var _a;
+            (_a = this.pdfDocument) === null || _a === void 0 ? void 0 : _a.getPagePdfSize(page).then((pageSize) => {
+                resolve(pageSize);
+            });
+        });
+    }
+    setLicenseKey(key) {
+        try {
+            PdfViewing.Sdk.initialize(key, PdfViewing.Sdk.version);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    getSupportedFeatures() {
+        return PdfViewing.Sdk.supportedFeatures;
+    }
+    hasChanges() {
+        if (this.pdfDocument) {
+            const changes = this.pdfDocument.hasChanges;
+            let ret = DocumentChange.NONE;
+            if (changes & PdfViewing.Pdf.DocumentChange.Annotation) {
+                ret = ret | DocumentChange.ANNOTATION;
+            }
+            if (changes & PdfViewing.Pdf.DocumentChange.Content) {
+                ret = ret | DocumentChange.CONTENT;
+            }
+            return ret;
+        }
+        return null;
+    }
+    getSearchIterator(keyword, page, caseSensitive, wrap, regex) {
+        var _a;
+        try {
+            return (_a = this.pdfDocument) === null || _a === void 0 ? void 0 : _a.searchText(keyword, page, caseSensitive, wrap, regex);
+        }
+        catch (err) {
+            if (err.message !== 'Invalid search text') {
+                throw err;
+            }
+            console.warn(err.message);
+        }
+    }
+    getTextFragmentOnPoint(point) {
+        var _a;
+        const pointOnVp = new PdfViewing.Pdf.Geometry.Integer.Point(point.x, point.y);
+        if (this.pdfDocument === null)
+            return null;
+        try {
+            const fragmentList = (_a = this.view) === null || _a === void 0 ? void 0 : _a.getTextFragmentsOnPoint(pointOnVp);
+            let frag = null;
+            if (fragmentList && fragmentList.size > 0) {
+                const nativeFrag = fragmentList.get(0);
+                frag = this.createWebViewerFragment(nativeFrag);
+                nativeFrag.close();
+                fragmentList === null || fragmentList === void 0 ? void 0 : fragmentList.close();
+            }
+            return frag;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    getWordOnPoint(point) {
+        var _a;
+        const pointOnPage = new PdfViewing.Pdf.Geometry.Real.PointOnPage(point.page, point.pdfX, point.pdfY);
+        try {
+            const selection = (_a = this.view) === null || _a === void 0 ? void 0 : _a.getWordOnPoint(pointOnPage);
+            if (selection) {
+                const { textArea } = selection;
+                if (textArea) {
+                    const quadrilaterals = [];
+                    for (let index = 0; index < textArea.size; index++) {
+                        quadrilaterals.push(textArea.get(index));
+                    }
+                    textArea.close();
+                    selection.close();
+                    const q = quadrilaterals[0];
+                    if (q) {
+                        const { bottomLeft, bottomRight, topRight, topLeft, pageNumber } = q;
+                        return {
+                            quadrilaterals,
+                            startPoint: {
+                                pdfX: Math.min(bottomLeft.x, bottomRight.x, topRight.x, topLeft.x),
+                                pdfY: Math.max(bottomLeft.y, bottomRight.y, topRight.y, topLeft.y),
+                                page: pageNumber,
+                            },
+                            endPoint: {
+                                pdfX: Math.max(bottomLeft.x, bottomRight.x, topRight.x, topLeft.x),
+                                pdfY: Math.min(bottomLeft.y, bottomRight.y, topRight.y, topLeft.y),
+                                page: pageNumber,
+                            },
+                        };
+                    }
+                }
+            }
+        }
+        catch (e) { }
+        return null;
+    }
+    getTextSelection(startPoint, endPoint) {
+        var _a;
+        const startPointOnPage = new PdfViewing.Pdf.Geometry.Real.PointOnPage(startPoint.page, startPoint.pdfX, startPoint.pdfY);
+        const endPointOnPage = new PdfViewing.Pdf.Geometry.Real.PointOnPage(endPoint.page, endPoint.pdfX, endPoint.pdfY);
+        try {
+            const selection = (_a = this.view) === null || _a === void 0 ? void 0 : _a.getTextSelection(startPointOnPage, endPointOnPage);
+            if (selection) {
+                const { textArea } = selection;
+                if (textArea) {
+                    const quadrilaterals = [];
+                    for (let index = 0; index < textArea.size; index++) {
+                        quadrilaterals.push(textArea.get(index));
+                    }
+                    textArea.close();
+                    selection.close();
+                    return {
+                        quadrilaterals,
+                        startPoint,
+                        endPoint,
+                    };
+                }
+            }
+        }
+        catch (e) { }
+        return null;
+    }
+    getRectangularTextSelection(startPoint, endPoint) {
+        var _a;
+        const startPointOnPage = new PdfViewing.Pdf.Geometry.Real.PointOnPage(startPoint.page, startPoint.pdfX, startPoint.pdfY);
+        const endPointOnPage = new PdfViewing.Pdf.Geometry.Real.PointOnPage(endPoint.page, endPoint.pdfX, endPoint.pdfY);
+        try {
+            const selection = (_a = this.view) === null || _a === void 0 ? void 0 : _a.getRectangularTextSelection(startPointOnPage, endPointOnPage);
+            if (selection) {
+                const { textArea } = selection;
+                if (textArea) {
+                    const quadrilaterals = [];
+                    for (let index = 0; index < textArea.size; index++) {
+                        quadrilaterals.push(textArea.get(index));
+                    }
+                    textArea.close();
+                    selection.close();
+                    return {
+                        quadrilaterals,
+                        startPoint,
+                        endPoint,
+                    };
+                }
+            }
+        }
+        catch (err) { }
+        return null;
+    }
+    getText(startPoint, endPoint) {
+        var _a;
+        const startPointOnPage = new PdfViewing.Pdf.Geometry.Real.PointOnPage(startPoint.page, startPoint.pdfX, startPoint.pdfY);
+        const endPointOnPage = new PdfViewing.Pdf.Geometry.Real.PointOnPage(endPoint.page, endPoint.pdfX, endPoint.pdfY);
+        try {
+            const selection = (_a = this.view) === null || _a === void 0 ? void 0 : _a.getTextSelection(startPointOnPage, endPointOnPage);
+            if (selection) {
+                const { text } = selection;
+                selection.close();
+                return text;
+            }
+        }
+        catch (e) { }
+        return null;
+    }
+    getTextForRectangularSelection(startPoint, endPoint) {
+        var _a;
+        const startPointOnPage = new PdfViewing.Pdf.Geometry.Real.PointOnPage(startPoint.page, startPoint.pdfX, startPoint.pdfY);
+        const endPointOnPage = new PdfViewing.Pdf.Geometry.Real.PointOnPage(endPoint.page, endPoint.pdfX, endPoint.pdfY);
+        try {
+            const selection = (_a = this.view) === null || _a === void 0 ? void 0 : _a.getRectangularTextSelection(startPointOnPage, endPointOnPage);
+            if (selection) {
+                const { text } = selection;
+                selection.close();
+                return text;
+            }
+        }
+        catch (e) { }
+        return null;
+    }
+    createWebViewerFragment(nativeFragment) {
+        const fragment = {};
+        fragment.glyphOffsets = nativeFragment.glyphOffsets ? nativeFragment.glyphOffsets : [];
+        fragment.text = nativeFragment.text || '';
+        // Convert Tetragon to Rect
+        const fragRect = nativeFragment.rectangleOnPage;
+        if (fragRect) {
+            fragment.pdfRect = this.ViewingPdfRect2WwPdfRect(fragRect);
+        }
+        return fragment;
+    }
+    getIsOpen() {
+        return this.pdfDocument !== null;
+    }
+    getOutlines(parent) {
+        return new Promise((resolve, reject) => {
+            if (this.pdfDocument) {
+                if (parent !== null) {
+                    parent = this.nativeOutlines.get(parent.id);
+                }
+                this.pdfDocument
+                    .getOutlines(parent)
+                    .then((outlineList) => {
+                    const outlines = [];
+                    for (let i = 0; i < outlineList.size; i++) {
+                        const nativeOutline = outlineList.get(i);
+                        const outline = {};
+                        outline.id = nativeOutline.getHashCode();
+                        outline.title = nativeOutline.title || '';
+                        outline.hasDescendants = nativeOutline.hasChildren;
+                        outline.destination = nativeOutline.destination;
+                        this.nativeOutlines.set(nativeOutline.getHashCode(), nativeOutline);
+                        outlines.push(outline);
+                    }
+                    outlineList.close();
+                    resolve(outlines);
+                })
+                    .catch((err) => {
+                    if (err.message !== 'Document was closed before operation could finish') {
+                        reject('failed to get outlines');
+                    }
+                });
+            }
+            else {
+                reject();
+            }
+        });
+    }
+    goTo(destination) {
+        if (destination != null)
+            this.goToPage(destination.pageNumber, destination.left, destination.top, destination.zoom);
+    }
+    goToPage(pageNumber, left = null, top = null, zoom = null) {
+        if (this.view) {
+            const nativeDest = new PdfViewing.Pdf.Navigation.LocationZoomDestination(pageNumber, left, top, zoom);
+            this.view.goToDestination(nativeDest);
+        }
+    }
+    goToRectangle(rectangle) {
+        if (this.view) {
+            const rectangleOnPage = new PdfViewing.Pdf.Geometry.Real.RectangleOnPage(rectangle.page, rectangle.pdfX, rectangle.pdfY, rectangle.pdfW, rectangle.pdfH);
+            this.view.goToRectangle(rectangleOnPage);
+        }
+    }
+    getAnnotationsFromPage(page) {
+        return new Promise((resolve, reject) => {
+            var _a;
+            (_a = this.pdfDocument) === null || _a === void 0 ? void 0 : _a.getAnnotations(page).then((annotList) => {
+                var _a;
+                const annotRet = {};
+                annotRet.page = page;
+                annotRet.itemCategory = 1;
+                annotRet.items = [];
+                for (let i = 0; i < annotList.size; i++) {
+                    const nativeAnnot = annotList.get(i);
+                    const ww_annot = this.createWebViewerAnnotation(nativeAnnot, page);
+                    if (ww_annot) {
+                        annotRet.items.push(ww_annot);
+                        this.nativeAnnotationCache.set(ww_annot.id, nativeAnnot);
+                        this.handleAnnotationCache.set(ww_annot.id, ww_annot);
+                        if (!this.pageAnnotationCache.has(page)) {
+                            this.pageAnnotationCache.set(page, []);
+                        }
+                        (_a = this.pageAnnotationCache.get(page)) === null || _a === void 0 ? void 0 : _a.push(ww_annot);
+                    }
+                }
+                resolve(annotRet);
+            }).catch((err) => {
+                if (err.message !== 'Document was closed before operation could finish') {
+                    reject(`Failed to get annotations for page ${page}, ${err}`);
+                }
+            });
+        });
+    }
+    deleteItem(item) {
+        return this.deleteAnnotation(item);
+    }
+    validateViewingSdkVersion() {
+        const parseVersionString = (versionString) => {
+            const match = versionString.match(/(\d+)\.(\d+)\.(\d+)[\-]{0,1}(\w*)[\.]{0,1}(\d*)/);
+            if (match) {
+                return {
+                    major: parseInt(match[1]),
+                    minor: parseInt(match[2]),
+                    patch: parseInt(match[3]),
+                    type: match[4],
+                    buildId: parseInt(match[5]),
+                };
+            }
+        };
+        // 4.3.6-rc.17600 will be replaced with the current PdfViewing SDK Version by webpack
+        const requiredSdk = parseVersionString('4.3.6-rc.17600');
+        const currentSdk = parseVersionString(PdfViewing.Sdk.version);
+        if (requiredSdk && currentSdk) {
+            const valid = requiredSdk.major === currentSdk.major &&
+                requiredSdk.minor === currentSdk.minor &&
+                requiredSdk.patch === currentSdk.patch &&
+                (requiredSdk.type ? requiredSdk.buildId === currentSdk.buildId : true);
+            if (!valid) {
+                console.warn(`**************************************
+Version mismatch between PDF Viewing SDK and  PDF Web Viewer
+
+Most likely, the static assets of the PDF Viewing SDK have not been copied to the configured location. For more information please consult the documentation ("static assets").
+
+Current version: ${currentSdk.major}.${currentSdk.minor}.${currentSdk.patch}
+Required version: ${requiredSdk.major}.${requiredSdk.minor}.${requiredSdk.patch}${requiredSdk.type ? ` (${requiredSdk.type.toUpperCase()} version)` : ''}
+
+**************************************`);
+            }
+        }
+        else {
+            console.warn('The PDF Viewing SDK version number has an incorrect format');
+        }
+    }
+    deleteAnnotation(item) {
+        return new Promise((resolve, reject) => {
+            var _a;
+            const id = item.id;
+            const nativeAnnot = this.nativeAnnotationCache.get(id);
+            const page = item.page;
+            if (nativeAnnot) {
+                (_a = this.pdfDocument) === null || _a === void 0 ? void 0 : _a.deleteAnnotation(nativeAnnot).then(() => {
+                    nativeAnnot.close();
+                    this.nativeAnnotationCache.delete(id);
+                    this.handleAnnotationCache.delete(id);
+                    this.dispatchEvent('itemDeleted', { page, id, categoryType: 1 });
+                    this.dispatchEvent('pageChanged', page);
+                    resolve();
+                });
+            }
+        });
+    }
+    getItem(id) {
+        if (this.handleAnnotationCache.has(id)) {
+            return this.handleAnnotationCache.get(id);
+        }
+        return null;
+    }
+    createItem(item) {
+        return this.createAnnotation(item);
+    }
+    createAnnotationFilter(annotationFilter) {
+        return (annot) => {
+            const { pageNumber } = annot.boundingBox;
+            const ww_annot = this.createWebViewerAnnotation(annot, pageNumber);
+            annot.close();
+            const res = annotationFilter(ww_annot);
+            return res;
+        };
+    }
+    createMarkupAnnotation(item) {
+        const color = this.createNativeColor(item.color);
+        const fillColor = this.createNativeColor(item.fillColor);
+        let borderStyle = PdfViewing.Pdf.Annotations.BorderStyleType.Lined;
+        const stroke = new PdfViewing.Pdf.Annotations.AnnotationStroke();
+        if (item.border) {
+            stroke.lineWidth = item.border.width;
+            borderStyle = this.convertToNativeBorderStyle(item.border.style);
+            if (item.border.style === 1) {
+                stroke.dashArray = [item.border.width];
+            }
+        }
+        const bbox = new PdfViewing.Pdf.Geometry.Real.RectangleOnPage(item.pdfRect.page, item.pdfRect.pdfX, item.pdfRect.pdfY, item.pdfRect.pdfW, item.pdfRect.pdfH);
+        switch (item.itemType) {
+            case 1: // Sticky Note
+                const stickyOrigin = new PdfViewing.Pdf.Geometry.Real.PointOnPage(item.pdfRect.page, item.pdfRect.pdfX, item.pdfRect.pdfY);
+                return PdfViewing.Pdf.Annotations.StickyNote.create(stickyOrigin, '', color);
+            case 3: // Freetext
+                return PdfViewing.Pdf.Annotations.FreeText.create(bbox, item.richtext, color, stroke, this.view ? this.view.viewRotation : PdfViewing.Pdf.Geometry.Rotation.NoRotation);
+            case 5: // Rectangle
+                return PdfViewing.Pdf.Annotations.RectangleAnnotation.create(bbox, stroke.lineWidth ? color : null, stroke, borderStyle, fillColor);
+            case 6: // Ellipse
+                return PdfViewing.Pdf.Annotations.EllipseAnnotation.create(bbox, stroke.lineWidth ? color : null, stroke, borderStyle, fillColor);
+            case 9: // Highlight
+                return PdfViewing.Pdf.Annotations.Highlight.create(this.createQuadrilateralList(item.quadrilaterals), color);
+            case 10: // Underline
+                return PdfViewing.Pdf.Annotations.Underline.create(this.createQuadrilateralList(item.quadrilaterals), color);
+            case 11: // Squiggly
+                return PdfViewing.Pdf.Annotations.Squiggly.create(this.createQuadrilateralList(item.quadrilaterals), color);
+            case 12: // StrikeThrough
+                return PdfViewing.Pdf.Annotations.StrikeThrough.create(this.createQuadrilateralList(item.quadrilaterals), color);
+            case 13: // Text Stamp
+                if (item.stampText) {
+                    return PdfViewing.Pdf.Annotations.CustomTextStamp.create(bbox, item.stampText, item.stampColor, this.view ? this.view.viewRotation : PdfViewing.Pdf.Geometry.Rotation.NoRotation);
+                }
+                else if (item.imageId) {
+                    return PdfViewing.Pdf.Annotations.CustomImageStamp.create(bbox, item.imageId, this.view ? this.view.viewRotation : PdfViewing.Pdf.Geometry.Rotation.NoRotation);
+                }
+                else {
+                    throw new Error(`createAnnotation: Unknown custom stamp annotation`);
+                }
+            case 15: // Ink
+                const inkList = item.inkList;
+                const path = new PdfViewing.Pdf.Geometry.Real.Path();
+                if (inkList) {
+                    const pathGen = new PdfViewing.Pdf.Geometry.Real.PathGenerator(path);
+                    for (let i = 0; i < inkList.length; i++) {
+                        pathGen.moveTo(new PdfViewing.Pdf.Geometry.Real.Point(inkList[i][0], inkList[i][1]));
+                        for (let j = 2; j < inkList[i].length; j += 2) {
+                            pathGen.lineTo(new PdfViewing.Pdf.Geometry.Real.Point(inkList[i][j], inkList[i][j + 1]));
+                        }
+                    }
+                    pathGen.close();
+                }
+                return PdfViewing.Pdf.Annotations.InkAnnotation.create(item.page, path, color, stroke);
+            default:
+                throw new Error(`createAnnotation: Type not implemented: ${item.itemType}`);
+        }
+    }
+    createAnnotation(item) {
+        let annot = this.createMarkupAnnotation(item);
+        const page = item.page;
+        // Set general properties
+        annot.info.author = item.author || '';
+        return new Promise((resolve, reject) => {
+            var _a;
+            (_a = this.pdfDocument) === null || _a === void 0 ? void 0 : _a.createAnnotation(annot).then(() => {
+                const ww_annot = this.createWebViewerAnnotation(annot, item.page);
+                if (ww_annot) {
+                    this.nativeAnnotationCache.set(ww_annot.id, annot);
+                    this.handleAnnotationCache.set(ww_annot.id, ww_annot);
+                    this.dispatchEvent('itemCreated', ww_annot);
+                    this.dispatchEvent('pageChanged', page);
+                    resolve(ww_annot);
+                }
+                reject('Failed to create Web Viewer annotation');
+            }).catch((error) => {
+                reject(error);
+            });
+        });
+    }
+    createQuadrilateralList(quadrilaterals) {
+        const quadrilateralList = new PdfViewing.Pdf.Geometry.Real.QuadrilateralList();
+        for (let i = 0; i < quadrilaterals.length; i++) {
+            const q = quadrilaterals[i];
+            quadrilateralList.add(new PdfViewing.Pdf.Geometry.Real.QuadrilateralOnPage(q.pageNumber, new PdfViewing.Pdf.Geometry.Real.Point(q.bottomLeft.x, q.bottomLeft.y), new PdfViewing.Pdf.Geometry.Real.Point(q.bottomRight.x, q.bottomRight.y), new PdfViewing.Pdf.Geometry.Real.Point(q.topRight.x, q.topRight.y), new PdfViewing.Pdf.Geometry.Real.Point(q.topLeft.x, q.topLeft.y)));
+        }
+        return quadrilateralList;
+    }
+    convertToNativeBorderStyle(style) {
+        switch (style) {
+            case 0:
+                return PdfViewing.Pdf.Annotations.BorderStyleType.Lined;
+            case 2:
+                return PdfViewing.Pdf.Annotations.BorderStyleType.Beveled;
+            case 3:
+                return PdfViewing.Pdf.Annotations.BorderStyleType.Inset;
+            case 4:
+                return PdfViewing.Pdf.Annotations.BorderStyleType.Underline;
+            default:
+                return PdfViewing.Pdf.Annotations.BorderStyleType.Lined;
+        }
+    }
+    convertToWebViewerBorderStyle(style) {
+        switch (style) {
+            case PdfViewing.Pdf.Annotations.BorderStyleType.Lined:
+                return 0;
+            case PdfViewing.Pdf.Annotations.BorderStyleType.Beveled:
+                return 2;
+            case PdfViewing.Pdf.Annotations.BorderStyleType.Inset:
+                return 3;
+            case PdfViewing.Pdf.Annotations.BorderStyleType.Underline:
+                return 4;
+            default:
+                return 0;
+        }
+    }
+    updateItem(item) {
+        return new Promise((resolve, reject) => {
+            var _a, _b;
+            if (item.itemType === PdfItemType.WIDGET) {
+                (_a = this.pdfDocument) === null || _a === void 0 ? void 0 : _a.editAnnotation(item.widget).then(() => {
+                    // this.dispatchEvent('itemUpdated', item)
+                    this.dispatchEvent('pageChanged', item.widget.boundingBox.pageNumber);
+                    resolve(item);
+                }).catch((error) => {
+                    reject(error);
+                });
+            }
+            else {
+                const nativeAnnot = this.nativeAnnotationCache.get(item.id);
+                if (nativeAnnot) {
+                    const rotationChanged = item.hasOwnProperty('rotation') &&
+                        item.rotation % 360 !== nativeAnnot.rotation % 360;
+                    if (!rotationChanged) {
+                        const bbox = new PdfViewing.Pdf.Geometry.Real.RectangleOnPage(item.pdfRect.page, item.pdfRect.pdfX, item.pdfRect.pdfY, item.pdfRect.pdfW, item.pdfRect.pdfH);
+                        nativeAnnot.boundingBox = bbox;
+                    }
+                    let nativeColor = null;
+                    nativeColor = this.createNativeColor(item.color);
+                    const markupAnnot = nativeAnnot;
+                    if (markupAnnot && item.privateData) {
+                        markupAnnot.privateData = item.privateData;
+                    }
+                    if (nativeAnnot.popup) {
+                        const rect = item.popup.pdfRect;
+                        nativeAnnot.popup.boundingBox =
+                            new PdfViewing.Pdf.Geometry.Real.RectangleOnPage(rect.page, rect.pdfX, rect.pdfY, rect.pdfW, rect.pdfH);
+                        nativeAnnot.popup.isOpen = item.popup.isOpen;
+                    }
+                    if (markupAnnot && markupAnnot.info) {
+                        markupAnnot.info.content = item.content || '';
+                        markupAnnot.info.subject = item.subject || '';
+                    }
+                    if (item.itemType === PdfItemType.TEXT) {
+                        const stickyAnnot = nativeAnnot;
+                        stickyAnnot.color = nativeColor;
+                    }
+                    if (item.itemType === PdfItemType.FREE_TEXT) {
+                        const freetextAnnot = nativeAnnot;
+                        freetextAnnot.richText = item.richText;
+                        freetextAnnot.backgroundColor = this.createNativeColor(item.color);
+                        const stroke = freetextAnnot.annotationStroke;
+                        if (stroke) {
+                            stroke.lineWidth = item.border.width;
+                            freetextAnnot.annotationStroke = stroke;
+                            stroke.close();
+                        }
+                        if (rotationChanged) {
+                            freetextAnnot.rotation = item.rotation;
+                            item.pdfRect = {
+                                page: freetextAnnot.boundingBox.pageNumber,
+                                pdfX: freetextAnnot.boundingBox.x,
+                                pdfY: freetextAnnot.boundingBox.y,
+                                pdfW: freetextAnnot.boundingBox.width,
+                                pdfH: freetextAnnot.boundingBox.height,
+                            };
+                        }
+                    }
+                    if (item.itemType === PdfItemType.INK) {
+                        const inkAnnotation = nativeAnnot;
+                        const inkAnnot = item;
+                        inkAnnotation.strokeColor = nativeColor;
+                        const { annotationStroke } = inkAnnotation;
+                        if (annotationStroke) {
+                            annotationStroke.lineWidth = item.border.width;
+                            inkAnnotation.annotationStroke = annotationStroke;
+                        }
+                        const { path } = inkAnnotation;
+                        const { vertices } = path;
+                        vertices.clear();
+                        for (let line of inkAnnot.inkList) {
+                            let isFirstPoint = true;
+                            for (let point of line) {
+                                if (isFirstPoint) {
+                                    vertices.add(new PdfViewing.Pdf.Geometry.Real.Vertex(inkAnnot.page, point.x, point.y, PdfViewing.Pdf.Geometry.Real.PathOperation.MoveTo));
+                                    isFirstPoint = false;
+                                }
+                                else {
+                                    vertices.add(new PdfViewing.Pdf.Geometry.Real.Vertex(inkAnnot.page, point.x, point.y, PdfViewing.Pdf.Geometry.Real.PathOperation.LineTo));
+                                }
+                            }
+                        }
+                        path.vertices = vertices;
+                        inkAnnotation.setPath(path);
+                    }
+                    if (item.itemType === PdfItemType.SQUARE || item.itemType === PdfItemType.CIRCLE) {
+                        // ! using square annotation type because there is no common base class
+                        const shapeAnnotation = nativeAnnot;
+                        // update stroke
+                        const { annotationStroke } = shapeAnnotation;
+                        if (annotationStroke) {
+                            annotationStroke.lineWidth = item.border.width;
+                            if (item.border.style === 1) {
+                                annotationStroke.dashArray = [item.border.width];
+                            }
+                            else {
+                                annotationStroke.dashArray = [0];
+                            }
+                            shapeAnnotation.annotationStroke = annotationStroke;
+                        }
+                        shapeAnnotation.borderStyleType = this.convertToNativeBorderStyle(item.border.style);
+                        shapeAnnotation.strokeColor = nativeColor;
+                        shapeAnnotation.fillColor = this.createNativeColor(item.fillColor);
+                    }
+                    if (item.itemType === PdfItemType.HIGHLIGHT ||
+                        item.itemType === PdfItemType.SQUIGGLY ||
+                        item.itemType === PdfItemType.STRIKE_OUT ||
+                        item.itemType === PdfItemType.UNDERLINE) {
+                        const textMarkupAnnot = nativeAnnot;
+                        textMarkupAnnot.color = nativeColor;
+                    }
+                    if (item.itemType === PdfItemType.STAMP) {
+                        const stampAnnot = nativeAnnot;
+                        if (rotationChanged) {
+                            stampAnnot.rotation = item.rotation;
+                            item.pdfRect = {
+                                page: stampAnnot.boundingBox.pageNumber,
+                                pdfX: stampAnnot.boundingBox.x,
+                                pdfY: stampAnnot.boundingBox.y,
+                                pdfW: stampAnnot.boundingBox.width,
+                                pdfH: stampAnnot.boundingBox.height,
+                            };
+                        }
+                    }
+                    (_b = this.pdfDocument) === null || _b === void 0 ? void 0 : _b.editAnnotation(nativeAnnot).then(() => {
+                        const { pageNumber } = nativeAnnot.boundingBox;
+                        const updatedItem = this.createWebViewerAnnotation(nativeAnnot, pageNumber);
+                        if (updatedItem) {
+                            this.handleAnnotationCache.set(item.id, updatedItem);
+                            this.dispatchEvent('itemUpdated', updatedItem);
+                            this.dispatchEvent('pageChanged', pageNumber);
+                            resolve(updatedItem);
+                        }
+                        else {
+                            throw new Error('failed to update item');
+                        }
+                    }).catch((error) => {
+                        reject(error);
+                    });
+                }
+            }
+        });
+    }
+    getTextStampAspectRatio(stampText) {
+        return new Promise((resolve, reject) => {
+            var _a;
+            if (this.pdfDocument && this.view) {
+                (_a = this.pdfDocument) === null || _a === void 0 ? void 0 : _a.getTextStampAspectRatio(stampText).then((ratio) => {
+                    resolve(ratio);
+                });
+            }
+            else {
+                reject('No document opened');
+            }
+        });
+    }
+    createNativeColor(color) {
+        let red = 0;
+        let green = 0;
+        let blue = 0;
+        let alpha = 0;
+        if (!color) {
+            return new PdfViewing.Pdf.Annotations.Color(red, green, blue, alpha);
+        }
+        color = color.replace(/\s+/gi, '');
+        if (color.indexOf('#') === 0) {
+            if (color.length === 4) {
+                red = parseInt(color.substring(1, 2), 16);
+                green = parseInt(color.substring(2, 3), 16);
+                blue = parseInt(color.substring(3, 4), 16);
+                alpha = 255;
+            }
+            else if (color.length === 5) {
+                red = parseInt(color.substring(1, 2), 16);
+                green = parseInt(color.substring(2, 3), 16);
+                blue = parseInt(color.substring(3, 4), 16);
+                alpha = parseInt(color.substring(4, 5), 16);
+            }
+            else if (color.length === 7) {
+                red = parseInt(color.substring(1, 3), 16);
+                green = parseInt(color.substring(3, 5), 16);
+                blue = parseInt(color.substring(5, 7), 16);
+                alpha = 255;
+            }
+            else if (color.length === 9) {
+                red = parseInt(color.substring(1, 3), 16);
+                green = parseInt(color.substring(3, 5), 16);
+                blue = parseInt(color.substring(5, 7), 16);
+                alpha = parseInt(color.substring(7, 9), 16);
+            }
+            else {
+                throw new Error('invalid color string: ' + color);
+            }
+        }
+        else if (color.indexOf('rgb') === 0) {
+            const values = color.substring(color.indexOf('(') + 1, color.indexOf(')')).split(',');
+            if (values.length < 3 || values.length > 4) {
+                throw new Error('invalid color string: ' + color);
+            }
+            red = parseInt(values[0], 10);
+            green = parseInt(values[1], 10);
+            blue = parseInt(values[2], 10);
+            if (values.length === 4) {
+                alpha = Math.floor(parseFloat(values[3]) * 255);
+            }
+            else {
+                alpha = 255;
+            }
+        }
+        else {
+            throw new Error('invalid color string: ' + color);
+        }
+        return new PdfViewing.Pdf.Annotations.Color(red, green, blue, alpha);
+    }
+    createWebViewerAnnotation(annot, page) {
+        var _a, _b;
+        let ww_annot = {};
+        ww_annot.itemCategory = PdfItemCategory.ANNOTATION;
+        ww_annot.sourceTag = annot.sourceTag;
+        if (annot instanceof PdfViewing.Pdf.Annotations.MarkupAnnotation) {
+            const bbox = annot.boundingBox;
+            if (bbox) {
+                ww_annot.pdfRect = this.ViewingPdfRect2WwPdfRect(bbox);
+            }
+            ww_annot.page = page;
+            ww_annot.privateData = annot.privateData ? annot.privateData : null;
+            const info = annot.info;
+            if (info) {
+                ww_annot.content = info === null || info === void 0 ? void 0 : info.content;
+                ww_annot.author = (info === null || info === void 0 ? void 0 : info.author) || '';
+                ww_annot.id = info === null || info === void 0 ? void 0 : info.getHashCode();
+                ww_annot.modificationDate = (info === null || info === void 0 ? void 0 : info.modificationDate) || null;
+                ww_annot.creationDate = (info === null || info === void 0 ? void 0 : info.creationDate) || null;
+                ww_annot.subject = info === null || info === void 0 ? void 0 : info.subject;
+            }
+            ww_annot.isLocked = () => {
+                const cachedAnnotation = this.nativeAnnotationCache.get(ww_annot.id);
+                if (cachedAnnotation instanceof PdfViewing.Pdf.Annotations.MarkupAnnotation) {
+                    const markupAnnot = cachedAnnotation;
+                    if (markupAnnot.info) {
+                        return markupAnnot.info.locked;
+                    }
+                }
+                console.warn('annotation not found');
+                return false;
+            };
+            ww_annot.setLock = (isLocked) => {
+                const cachedAnnotation = this.nativeAnnotationCache.get(ww_annot.id);
+                if (cachedAnnotation instanceof PdfViewing.Pdf.Annotations.MarkupAnnotation) {
+                    const markupAnnot = cachedAnnotation;
+                    if (markupAnnot.info) {
+                        markupAnnot.info.locked = isLocked;
+                    }
+                }
+            };
+            if (annot instanceof PdfViewing.Pdf.Annotations.TextMarkup) {
+                ww_annot.color = this.convertColorToRgbaString(annot.color);
+            }
+            ww_annot.isHidden = () => {
+                const cachedAnnotation = this.nativeAnnotationCache.get(ww_annot.id);
+                if (!cachedAnnotation) {
+                    console.warn('annotation not found');
+                    return false;
+                }
+                return cachedAnnotation.hidden;
+            };
+            ww_annot.setHidden = (isHidden) => {
+                const cachedAnnotation = this.nativeAnnotationCache.get(ww_annot.id);
+                if (!cachedAnnotation) {
+                    console.warn('annotation not found');
+                    return false;
+                }
+                return (cachedAnnotation.hidden = isHidden);
+            };
+            ww_annot.border = {};
+            this.addPopup(ww_annot, annot);
+            if (annot instanceof PdfViewing.Pdf.Annotations.StickyNote) {
+                ww_annot.color = this.convertColorToRgbaString(annot.color);
+                ww_annot.itemType = PdfItemType.TEXT;
+            }
+            else if (annot instanceof PdfViewing.Pdf.Annotations.FreeText) {
+                ww_annot.itemType = PdfItemType.FREE_TEXT;
+                const freetextAnnot = annot;
+                const ww_freetextAnnot = ww_annot;
+                ww_freetextAnnot.richText =
+                    freetextAnnot.richText ||
+                        `<?xml version="1.0"?><body xmlns="http://www.w3.org/1999/xhtml" xmlns:xfa="http://www.xfa.org/schema/xfa-data/1.0/" xfa:APIVersion="Acrobat:21.11.0" xfa:spec="2.0.2" style="color:#000000;font-family:Helvetica;font-size:12pt;"><p>${annot.info.content}</p></body>`;
+                ww_freetextAnnot.rotation = freetextAnnot.rotation;
+                ww_freetextAnnot.color = this.convertColorToRgbaString(freetextAnnot.backgroundColor);
+                const stroke = freetextAnnot.annotationStroke;
+                if (stroke) {
+                    ww_freetextAnnot.border.width = stroke === null || stroke === void 0 ? void 0 : stroke.lineWidth;
+                    ww_freetextAnnot.border.style = 0;
+                    stroke.close();
+                }
+            }
+            else if (annot instanceof PdfViewing.Pdf.Annotations.RectangleAnnotation) {
+                const ww_shapeAnnot = ww_annot;
+                ww_shapeAnnot.itemType = PdfItemType.SQUARE;
+                ww_shapeAnnot.color = this.convertColorToRgbaString(annot.strokeColor);
+                const stroke = annot.annotationStroke;
+                if (stroke) {
+                    ww_shapeAnnot.border.width = stroke === null || stroke === void 0 ? void 0 : stroke.lineWidth;
+                    const hasDashArray = stroke.dashArray.length && stroke.dashArray[0] > 0;
+                    ww_shapeAnnot.border.style = hasDashArray
+                        ? 1
+                        : this.convertToWebViewerBorderStyle(annot.borderStyleType);
+                    stroke.close();
+                }
+                if (annot.fillColor) {
+                    ww_shapeAnnot.fillColor = this.convertColorToRgbaString(annot.fillColor);
+                }
+            }
+            else if (annot instanceof PdfViewing.Pdf.Annotations.EllipseAnnotation) {
+                const ww_shapeAnnot = ww_annot;
+                ww_shapeAnnot.itemType = PdfItemType.CIRCLE;
+                ww_shapeAnnot.color = this.convertColorToRgbaString(annot.strokeColor);
+                const stroke = annot.annotationStroke;
+                if (stroke) {
+                    ww_shapeAnnot.border.width = stroke === null || stroke === void 0 ? void 0 : stroke.lineWidth;
+                    const hasDashArray = stroke.dashArray.length && stroke.dashArray[0] > 0;
+                    ww_shapeAnnot.border.style = hasDashArray
+                        ? 1
+                        : this.convertToWebViewerBorderStyle(annot.borderStyleType);
+                    stroke.close();
+                }
+                if (annot.fillColor) {
+                    ww_shapeAnnot.fillColor = this.convertColorToRgbaString(annot.fillColor);
+                }
+            }
+            else if (annot instanceof PdfViewing.Pdf.Annotations.PolygonAnnotation) {
+                ww_annot.itemType = PdfItemType.POLYGON;
+                const stroke = annot.annotationStroke;
+                if (stroke) {
+                    ww_annot.border.width = stroke === null || stroke === void 0 ? void 0 : stroke.lineWidth;
+                    const hasDashArray = stroke.dashArray.length && stroke.dashArray[0] > 0;
+                    ww_annot.border.style = hasDashArray
+                        ? 1
+                        : this.convertToWebViewerBorderStyle(annot.borderStyleType);
+                }
+            }
+            else if (annot instanceof PdfViewing.Pdf.Annotations.PolyLineAnnotation) {
+                ww_annot.itemType = PdfItemType.POLY_LINE;
+                const stroke = annot.annotationStroke;
+                if (stroke) {
+                    ww_annot.border.width = stroke === null || stroke === void 0 ? void 0 : stroke.lineWidth;
+                    ww_annot.border.style = 0;
+                    stroke.close();
+                }
+            }
+            else if (annot instanceof PdfViewing.Pdf.Annotations.TextMarkup) {
+                const highlightAnnot = ww_annot;
+                highlightAnnot.markedText = annot.markedText;
+                if (annot.markupArea !== null) {
+                    highlightAnnot.quadrilaterals = [];
+                    for (let index = 0; index < annot.markupArea.size; index++) {
+                        highlightAnnot.quadrilaterals.push(annot.markupArea.get(index));
+                    }
+                }
+                if (annot instanceof PdfViewing.Pdf.Annotations.Highlight) {
+                    highlightAnnot.itemType = PdfItemType.HIGHLIGHT;
+                }
+                else if (annot instanceof PdfViewing.Pdf.Annotations.Underline) {
+                    highlightAnnot.itemType = PdfItemType.UNDERLINE;
+                }
+                else if (annot instanceof PdfViewing.Pdf.Annotations.Squiggly) {
+                    highlightAnnot.itemType = PdfItemType.SQUIGGLY;
+                }
+                else if (annot instanceof PdfViewing.Pdf.Annotations.StrikeThrough) {
+                    highlightAnnot.itemType = PdfItemType.STRIKE_OUT;
+                }
+            }
+            else if (annot instanceof PdfViewing.Pdf.Annotations.Stamp) {
+                const stampAnnot = ww_annot;
+                stampAnnot.itemType = PdfItemType.STAMP;
+                stampAnnot.rotation = annot.rotation;
+            }
+            else if (annot instanceof PdfViewing.Pdf.Annotations.TextInsert) {
+                return null;
+            }
+            else if (annot instanceof PdfViewing.Pdf.Annotations.InkAnnotation) {
+                const sdkInkAnnot = annot;
+                const inkAnnot = ww_annot;
+                inkAnnot.itemType = PdfItemType.INK;
+                inkAnnot.color = this.convertColorToRgbaString(sdkInkAnnot.strokeColor);
+                inkAnnot.border = {
+                    width: ((_a = sdkInkAnnot.annotationStroke) === null || _a === void 0 ? void 0 : _a.lineWidth) || 1,
+                    style: AnnotationBorderStyle.SOLID,
+                };
+                // extract inklist
+                inkAnnot.inkList = [];
+                const { vertices } = sdkInkAnnot.path;
+                let path = null;
+                for (let i = 0; i < vertices.size; i++) {
+                    const vertex = vertices.get(i);
+                    if (vertex.operator === PdfViewing.Pdf.Geometry.Real.PathOperation.MoveTo) {
+                        if (path) {
+                            inkAnnot.inkList.push(path);
+                        }
+                        path = [{ x: vertex.x, y: vertex.y }];
+                    }
+                    else if (vertex.operator === PdfViewing.Pdf.Geometry.Real.PathOperation.LineTo) {
+                        path === null || path === void 0 ? void 0 : path.push({ x: vertex.x, y: vertex.y });
+                    }
+                }
+                if (path) {
+                    inkAnnot.inkList.push(path);
+                }
+            }
+            else if (annot instanceof PdfViewing.Pdf.Annotations.Popup) {
+                return null;
+            }
+            else {
+                return null;
+            }
+        }
+        else if (annot instanceof PdfViewing.Pdf.Annotations.Link) {
+            ww_annot.itemType = PdfItemType.LINK;
+            const linkAnnot = ww_annot;
+            ww_annot.id = annot.getHashCode();
+            ww_annot.pdfRect = this.ViewingPdfRect2WwPdfRect(annot.boundingBox);
+            if (annot instanceof PdfViewing.Pdf.Annotations.WebLink) {
+                linkAnnot.uri = annot.uri;
+                linkAnnot.actionType = PdfActionType.URI;
+            }
+            else if (annot instanceof PdfViewing.Pdf.Annotations.InternalLink) {
+                const target = (_b = annot.destination) === null || _b === void 0 ? void 0 : _b.target;
+                linkAnnot.actionType = PdfActionType.GO_TO;
+                if (target) {
+                    linkAnnot.destination = {
+                        destinationType: 8,
+                        pageNumber: target.pageNumber,
+                        left: null,
+                        top: null,
+                        zoom: null,
+                    };
+                }
+            }
+        }
+        else if (annot instanceof PdfViewing.Pdf.Forms.Widget) {
+            const widgetAnnot = ww_annot;
+            widgetAnnot.id = annot.getHashCode();
+            widgetAnnot.itemType = PdfItemType.WIDGET;
+            widgetAnnot.page = page;
+            const bbox = annot.boundingBox;
+            widgetAnnot.pdfRect = this.ViewingPdfRect2WwPdfRect(bbox);
+            widgetAnnot.widget = annot;
+            widgetAnnot.isLocked = () => {
+                return false;
+            };
+            widgetAnnot.isHidden = () => {
+                return annot.hidden;
+            };
+            widgetAnnot.setHidden = (isHidden) => {
+                annot.hidden = isHidden;
+            };
+            widgetAnnot.pdfDocument = this.pdfDocument;
+            if (annot instanceof PdfViewing.Pdf.Forms.CheckBox) {
+                widgetAnnot.widgetType = WidgetType.CHECK_BOX;
+            }
+            else if (annot instanceof PdfViewing.Pdf.Forms.RadioButton) {
+                widgetAnnot.widgetType = WidgetType.RADIO_BUTTON;
+            }
+            else if (annot instanceof PdfViewing.Pdf.Forms.TextBox) {
+                widgetAnnot.widgetType = WidgetType.TEXT_BOX;
+            }
+            else if (annot instanceof PdfViewing.Pdf.Forms.ListBox) {
+                widgetAnnot.widgetType = WidgetType.LIST_BOX;
+            }
+            else if (annot instanceof PdfViewing.Pdf.Forms.ComboBox) {
+                widgetAnnot.widgetType = WidgetType.COMBO_BOX;
+                // } else if (annot instanceof PdfViewing.Pdf.Forms.ListBox) {
+                //   widgetAnnot.widgetType = WidgetType.STRING_LIST
+            }
+        }
+        else {
+            return null;
+        }
+        const isReadOnly = () => {
+            const { annotationPermissionCallback, onlyAuthorCanEdit, user } = this.pdfViewerApiOptions;
+            let eventThrottlingTimer = null;
+            let lastResult = false;
+            const viewOnly = this.pdfViewerApiOptions.viewOnly ||
+                !(PdfViewing.Sdk.supportedFeatures & PdfViewing.LicenseFeature.Annotate);
+            return () => {
+                if (eventThrottlingTimer) {
+                    return lastResult;
+                }
+                lastResult = false;
+                if (viewOnly || !(PdfViewing.Sdk.supportedFeatures & PdfViewing.LicenseFeature.Annotate)) {
+                    lastResult = true;
+                }
+                else if (annotationPermissionCallback) {
+                    lastResult = !annotationPermissionCallback(ww_annot, user);
+                }
+                else if (onlyAuthorCanEdit) {
+                    lastResult = !ww_annot.author || user !== ww_annot.author;
+                }
+                eventThrottlingTimer = window.setTimeout(() => {
+                    eventThrottlingTimer = null;
+                }, 50);
+                return lastResult;
+            };
+        };
+        ww_annot.isReadOnly = isReadOnly();
+        ww_annot.behaviors = this.getAnnotationBehaviors(ww_annot);
+        return ww_annot;
+    }
+    getAnnotationBehaviors(ww_annot) {
+        const defaultBehaviors = annotationDefaultBehaviors[ww_annot.itemType];
+        if (!defaultBehaviors) {
+            return {
+                isReadOnly: true,
+                selectable: false,
+                editable: false,
+                deletable: false,
+                movable: false,
+                rotatable: false,
+                resizable: false,
+                aspectRatioChangeable: false,
+                canHavePopup: false,
+                link: false,
+                text: false,
+            };
+        }
+        let isReadOnly = false;
+        if (this.pdfViewerApiOptions.viewOnly ||
+            !(this.licenseFeatures & PdfViewing.LicenseFeature.Annotate)) {
+            isReadOnly = true;
+        }
+        const behaviors = {
+            isReadOnly,
+            selectable: defaultBehaviors[0],
+            editable: defaultBehaviors[1],
+            deletable: defaultBehaviors[2],
+            movable: defaultBehaviors[3],
+            rotatable: defaultBehaviors[4],
+            resizable: defaultBehaviors[5],
+            aspectRatioChangeable: defaultBehaviors[6],
+            canHavePopup: this.pdfViewerApiOptions.allowPopups && defaultBehaviors[7],
+            link: defaultBehaviors[8],
+            text: defaultBehaviors[9],
+        };
+        return behaviors;
+    }
+    addPopup(ww_annot, annot) {
+        const popup = annot.popup;
+        if (popup) {
+            ww_annot.popup = {};
+            ww_annot.popup.pdfRect = this.ViewingPdfRect2WwPdfRect(popup.boundingBox);
+            ww_annot.popup.isOpen = popup.isOpen;
+            ww_annot.popup.pdfRect.page = ww_annot.page;
+            popup.close();
+        }
+    }
+    getOpenPopups(firstPage, lastPage) {
+        var _a;
+        const annotationsWithOpenPopups = [];
+        for (let i = firstPage; i <= lastPage; i++) {
+            (_a = this.pageAnnotationCache.get(i)) === null || _a === void 0 ? void 0 : _a.forEach((annot) => {
+                if (annot.popup && annot.popup.isOpen) {
+                    annotationsWithOpenPopups.push(annot);
+                }
+            });
+        }
+        return annotationsWithOpenPopups;
+    }
+    convertColorToRgbaString(color) {
+        let rgba_string = '#';
+        if (!color) {
+            rgba_string += '00000000';
+            return rgba_string;
+        }
+        // add red
+        rgba_string += color.red.toString(16).padStart(2, '0');
+        // add green
+        rgba_string += color.green.toString(16).padStart(2, '0');
+        // add blue
+        rgba_string += color.blue.toString(16).padStart(2, '0');
+        // add alpha
+        rgba_string += color.alpha.toString(16).padStart(2, '0');
+        return rgba_string;
+    }
+    getPageLayoutMode() {
+        if (this.view) {
+            return this.view.pageLayoutMode;
+        }
+        return PdfViewing.Pdf.Navigation.PageLayoutMode.SinglePage;
+    }
+    setPageLayoutMode(layout) {
+        if (this.view) {
+            this.view.pageLayoutMode = layout;
+        }
+    }
+    getScrollMaxPosition() {
+        var _a;
+        const sp = (_a = this.view) === null || _a === void 0 ? void 0 : _a.scrollMaxPosition;
+        if (sp) {
+            sp.x = Math.max(sp.x - this.viewportSize.width, 0);
+            sp.y = Math.max(sp.y - this.viewportSize.height, 0);
+        }
+        return sp;
+    }
+    getScrollPosition() {
+        var _a;
+        return (_a = this.view) === null || _a === void 0 ? void 0 : _a.scrollPosition;
+    }
+    setScrollPosition(pos) {
+        const sp = new PdfViewing.Pdf.Geometry.Integer.ScrollPosition(pos.x, pos.y);
+        if (this.view) {
+            this.view.scrollPosition = pos; //sp // TODO: Is this good? Or should I create a PdfViewing.ScrollPosition first?
+        }
+    }
+    getPageScreenRect(page) {
+        var _a;
+        const viewingRect = (_a = this.view) === null || _a === void 0 ? void 0 : _a.getPageRectangleOnViewport(page);
+        if (viewingRect) {
+            return this.ViewingVPRect2WwVpRect(viewingRect);
+        }
+        return null;
+    }
+    getClosestPointOnPdfByScreenPoint(point, padding = 0, page) {
+        if (this.view && this.pdfDocument) {
+            const p = new PdfViewing.Pdf.Geometry.Integer.Point(point.x, point.y);
+            const pointOnPage = page
+                ? this.view.transformPointFromViewportToSpecificPage(p, page, true)
+                : this.view.transformPointFromViewportToPage(p, true);
+            const pageSize = this.pdfDocument.getPageSize(pointOnPage.pageNumber, true);
+            const pdfPoint = {
+                pdfX: pointOnPage.x,
+                pdfY: pointOnPage.y,
+                page: pointOnPage.pageNumber,
+            };
+            if (pdfPoint.pdfX < padding) {
+                pdfPoint.pdfX = padding;
+            }
+            else if (pdfPoint.pdfX > pageSize.width - padding) {
+                pdfPoint.pdfX = pageSize.width - padding;
+            }
+            if (pdfPoint.pdfY < padding) {
+                pdfPoint.pdfY = padding;
+            }
+            else if (pdfPoint.pdfY > pageSize.height - padding) {
+                pdfPoint.pdfY = pageSize.height - padding;
+            }
+            return pdfPoint;
+        }
+        throw new Error('PDF Document must not be null');
+    }
+    transformPdfLengthToScreenLength(pdfLength) {
+        var _a;
+        if (this.view) {
+            return (_a = this.view) === null || _a === void 0 ? void 0 : _a.transformPdfLengthToViewportLength(pdfLength);
+        }
+        throw new Error('View must not be null');
+    }
+    transformScreenLengthToPdfLength(pdfLength) {
+        var _a;
+        if (this.view) {
+            return (_a = this.view) === null || _a === void 0 ? void 0 : _a.transformViewportLengthToPdfLength(pdfLength);
+        }
+        throw new Error('View must not be null');
+    }
+    transformScreenPointToPdfPoint(point, page) {
+        if (this.view && this.pdfDocument) {
+            const p = new PdfViewing.Pdf.Geometry.Integer.Point(point.x, point.y);
+            try {
+                const pointOnPage = page
+                    ? this.view.transformPointFromViewportToSpecificPage(p, page, false)
+                    : this.view.transformPointFromViewportToPage(p, false);
+                const pageSize = this.pdfDocument.getPageSize(pointOnPage.pageNumber, true);
+                return {
+                    pdfPoint: { pdfX: pointOnPage.x, pdfY: pointOnPage.y, page: pointOnPage.pageNumber },
+                    isOnPage: pointOnPage.x >= 0 &&
+                        pointOnPage.x <= pageSize.width &&
+                        pointOnPage.y >= 0 &&
+                        pointOnPage.y <= pageSize.height,
+                };
+            }
+            catch (error) {
+                if (error instanceof PdfViewing.ArgumentError) {
+                    return { pdfPoint: null, isOnPage: false };
+                }
+            }
+        }
+        return null;
+    }
+    transformPdfPointToScreenPoint(pdfPoint) {
+        var _a;
+        const screenPoint = (_a = this.view) === null || _a === void 0 ? void 0 : _a.transformPointFromPageToViewport(new PdfViewing.Pdf.Geometry.Real.PointOnPage(pdfPoint.page, pdfPoint.pdfX, pdfPoint.pdfY));
+        return {
+            x: screenPoint === null || screenPoint === void 0 ? void 0 : screenPoint.x,
+            y: screenPoint === null || screenPoint === void 0 ? void 0 : screenPoint.y,
+        };
+    }
+    transformPdfPageRectToScreenRect(pdfRect) {
+        var _a;
+        const screenRect = (_a = this.view) === null || _a === void 0 ? void 0 : _a.transformRectangleFromPageToViewport(new PdfViewing.Pdf.Geometry.Real.RectangleOnPage(pdfRect.page, pdfRect.pdfX, pdfRect.pdfY, pdfRect.pdfW, pdfRect.pdfH));
+        return {
+            x: screenRect === null || screenRect === void 0 ? void 0 : screenRect.x,
+            y: screenRect === null || screenRect === void 0 ? void 0 : screenRect.y,
+            w: screenRect === null || screenRect === void 0 ? void 0 : screenRect.width,
+            h: screenRect === null || screenRect === void 0 ? void 0 : screenRect.height,
+        };
+    }
+    transformScreenRectToPdfRect(screenRect, page) {
+        var _a;
+        const vpRect = new PdfViewing.Pdf.Geometry.Integer.Rectangle(screenRect.x, screenRect.y, screenRect.w, screenRect.h);
+        try {
+            const pdfRect = (_a = this.view) === null || _a === void 0 ? void 0 : _a.transformRectangleFromViewportToSpecificPage(vpRect, page);
+            return {
+                pdfX: pdfRect === null || pdfRect === void 0 ? void 0 : pdfRect.x,
+                pdfY: pdfRect === null || pdfRect === void 0 ? void 0 : pdfRect.y,
+                pdfW: pdfRect === null || pdfRect === void 0 ? void 0 : pdfRect.width,
+                pdfH: pdfRect === null || pdfRect === void 0 ? void 0 : pdfRect.height,
+                page,
+            };
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    transformQuadrilateralToViewport(quadrilateral) {
+        const points = [];
+        if (this.view) {
+            points.push(this.view.transformPointFromPageToViewport(new PdfViewing.Pdf.Geometry.Real.PointOnPage(quadrilateral.pageNumber, quadrilateral.topLeft.x, quadrilateral.topLeft.y)));
+            points.push(this.view.transformPointFromPageToViewport(new PdfViewing.Pdf.Geometry.Real.PointOnPage(quadrilateral.pageNumber, quadrilateral.topRight.x, quadrilateral.topRight.y)));
+            points.push(this.view.transformPointFromPageToViewport(new PdfViewing.Pdf.Geometry.Real.PointOnPage(quadrilateral.pageNumber, quadrilateral.bottomRight.x, quadrilateral.bottomRight.y)));
+            points.push(this.view.transformPointFromPageToViewport(new PdfViewing.Pdf.Geometry.Real.PointOnPage(quadrilateral.pageNumber, quadrilateral.bottomLeft.x, quadrilateral.bottomLeft.y)));
+        }
+        return points;
+    }
+    getAnnotationsOnPoint(point, onlySelectable) {
+        var _a;
+        const annotList = (_a = this.view) === null || _a === void 0 ? void 0 : _a.getAnnotationsOnPoint(point, onlySelectable);
+        if (annotList && annotList.size > 0) {
+            const annotationList = [];
+            for (let i = 0; i < annotList.size; i++) {
+                const annot = annotList.get(i);
+                const annotId = annot.getHashCode();
+                if (this.handleAnnotationCache.has(annotId)) {
+                    annotationList.push(this.handleAnnotationCache.get(annotId));
+                }
+                else {
+                    console.warn('annotation handle is not cached');
+                }
+                annot.close();
+            }
+            annotList.close();
+            return annotationList;
+        }
+        return null;
+    }
+    getItemsFromPage(page, type) {
+        if (type === 1) {
+            return this.getAnnotationsFromPage(page);
+        }
+    }
+    onDocumentOpened(document, renderOptions, viewOptions) {
+        const _viewOptions = viewOptions ? viewOptions : new PdfViewing.Pdf.ViewOptions();
+        _viewOptions.viewDPI = this.getXDPI();
+        const { initialDestination, initialPageLayoutMode } = document;
+        if (initialPageLayoutMode !== null && _viewOptions.initialPageLayoutMode === null) {
+            _viewOptions.initialPageLayoutMode = initialPageLayoutMode;
+        }
+        if (initialDestination !== null && _viewOptions.initialDestination === null) {
+            _viewOptions.initialDestination = initialDestination;
+        }
+        this.view = PdfViewing.Pdf.View.create(document, renderOptions, viewOptions);
+        this.attachEventListeners();
+        if (this.view) {
+            this.dispatchEvent('firstVisiblePage', this.view.firstVisiblePage);
+            this.dispatchEvent('lastVisiblePage', this.view.lastVisiblePage);
+            this.dispatchEvent('pageNumber', this.view.pageNumber);
+            this.dispatchEvent('fitMode', this.view.fitMode);
+            this.dispatchEvent('pageLayoutMode', this.ViewingPageLayoutToWwPageLayout(this.view.pageLayoutMode));
+        }
+    }
+    ViewingPageLayoutToWwPageLayout(layout) {
+        switch (layout) {
+            case PdfViewing.Pdf.Navigation.PageLayoutMode.OneColumn:
+                return PdfPageLayoutMode.ONE_COLUMN;
+            case PdfViewing.Pdf.Navigation.PageLayoutMode.SinglePage:
+                return PdfPageLayoutMode.SINGLE_PAGE;
+            case PdfViewing.Pdf.Navigation.PageLayoutMode.TwoColumnLeft:
+                return PdfPageLayoutMode.TWO_COLUMN_LEFT;
+            case PdfViewing.Pdf.Navigation.PageLayoutMode.TwoColumnRight:
+                return PdfPageLayoutMode.TWO_COLUMN_RIGHT;
+            case PdfViewing.Pdf.Navigation.PageLayoutMode.TwoPageLeft:
+                return PdfPageLayoutMode.TWO_PAGE_LEFT;
+            case PdfViewing.Pdf.Navigation.PageLayoutMode.TwoPageRight:
+                return PdfPageLayoutMode.TWO_PAGE_RIGHT;
+            default:
+                return PdfPageLayoutMode.ONE_COLUMN;
+        }
+    }
+    WwPageLayoutToViewingPageLayout(layout) {
+        switch (layout) {
+            case PdfPageLayoutMode.ONE_COLUMN:
+                return PdfViewing.Pdf.Navigation.PageLayoutMode.OneColumn;
+            case PdfPageLayoutMode.SINGLE_PAGE:
+                return PdfViewing.Pdf.Navigation.PageLayoutMode.SinglePage;
+            case PdfPageLayoutMode.TWO_COLUMN_LEFT:
+                return PdfViewing.Pdf.Navigation.PageLayoutMode.TwoColumnLeft;
+            case PdfPageLayoutMode.TWO_COLUMN_RIGHT:
+                return PdfViewing.Pdf.Navigation.PageLayoutMode.TwoColumnRight;
+            case PdfPageLayoutMode.TWO_PAGE_LEFT:
+                return PdfViewing.Pdf.Navigation.PageLayoutMode.TwoPageLeft;
+            case PdfPageLayoutMode.TWO_PAGE_RIGHT:
+                return PdfViewing.Pdf.Navigation.PageLayoutMode.TwoPageRight;
+            case PdfPageLayoutMode.ONE_COLUMN:
+            default:
+                return PdfViewing.Pdf.Navigation.PageLayoutMode.OneColumn;
+        }
+    }
+    WwFitModeToViewingFitMode(fitMode) {
+        switch (fitMode) {
+            case PdfFitMode.NONE:
+                return PdfViewing.Pdf.Navigation.FitMode.None;
+            case PdfFitMode.FIT_PAGE:
+                return PdfViewing.Pdf.Navigation.FitMode.FitPage;
+            case PdfFitMode.FIT_WIDTH:
+                return PdfViewing.Pdf.Navigation.FitMode.FitWidth;
+            default:
+                return PdfViewing.Pdf.Navigation.FitMode.None;
+        }
+    }
+    getLastVisiblePage() {
+        if (this.view) {
+            return this.view.lastVisiblePage;
+        }
+        return 0;
+    }
+    getFirstVisiblePage() {
+        if (this.view) {
+            return this.view.firstVisiblePage;
+        }
+        return 0;
+    }
+    drawImages(ctx, data, options) {
+        if (data.visiblePages) {
+            ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
+            const currentPage = this.getPageNumber();
+            for (let i = 0; i < data.visiblePages.size; i++) {
+                const { image, pageRect, pageNumber } = data.visiblePages.get(i);
+                ctx.save();
+                if (currentPage === pageNumber && options.currentPageShadow) {
+                    ctx.shadowColor = options.currentPageShadow.shadowColor;
+                    ctx.shadowBlur = options.currentPageShadow.shadowBlur;
+                    ctx.shadowOffsetX = options.currentPageShadow.shadowOffsetX;
+                    ctx.shadowOffsetY = options.currentPageShadow.shadowOffsetY;
+                }
+                else if (options.pageShadow) {
+                    ctx.shadowColor = options.pageShadow.shadowColor;
+                    ctx.shadowBlur = options.pageShadow.shadowBlur;
+                    ctx.shadowOffsetX = options.pageShadow.shadowOffsetX;
+                    ctx.shadowOffsetY = options.pageShadow.shadowOffsetY;
+                }
+                ctx.fillStyle = '#ffffffff';
+                ctx.fillRect(pageRect.x, pageRect.y, pageRect.width, pageRect.height);
+                ctx.restore();
+                if (image) {
+                    const imageContainer = this.imageBitmapCache.get(image.id);
+                    if (imageContainer) {
+                        const { scaledImage, imageData } = imageContainer;
+                        const { imageRectangle } = image;
+                        if (imageData && scaledImage) {
+                            if (imageRectangle.width !== image.width || imageRectangle.height !== image.height) {
+                                ctx.drawImage(scaledImage, pageRect.x + imageRectangle.x, pageRect.y + imageRectangle.y, imageRectangle.width, imageRectangle.height);
+                            }
+                            else {
+                                ctx.putImageData(imageData, pageRect.x + imageRectangle.x, pageRect.y + imageRectangle.y);
+                            }
+                        }
+                    }
+                    image.close();
+                }
+            }
+        }
+    }
+    addEventListener(type, listener) {
+        if (type === 'busyState') {
+            this.pdfController.addEventListener('busyChanged', listener);
+            return;
+        }
+        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);
+            }
+        }
+    }
+    dispatchEvent(type, args) {
+        if (this.eventListeners.has(type)) {
+            const listeners = this.eventListeners.get(type);
+            listeners.forEach((listener) => listener(args));
+        }
+    }
+    attachEventListeners() {
+        if (this.view) {
+            this.view.addEventListener('viewUpdated', this.onViewUpdated);
+            this.view.addEventListener('imageCreated', this.onImageCreated);
+            this.view.addEventListener('imageRemovedFromCache', this.onImageRemovedFromCache);
+        }
+    }
+    onViewUpdated(args) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        if (args.bitmapsUpdated) {
+        }
+        if (args.fitmodeChanged) {
+            (_a = this.eventListeners.get('fitMode')) === null || _a === void 0 ? void 0 : _a.forEach((listener) => {
+                listener(this.view ? this.view.fitMode : PdfViewing.Pdf.Navigation.FitMode.None);
+            });
+        }
+        if (args.pageLayoutModeChanged) {
+            (_b = this.eventListeners.get('pageLayoutMode')) === null || _b === void 0 ? void 0 : _b.forEach((listener) => {
+                listener(this.view ? this.view.pageLayoutMode : 0);
+            });
+        }
+        if (args.pageSizeUpdated) {
+        }
+        if (args.scrollMaxPositionChanged) {
+        }
+        if (args.viewRotationChanged) {
+            (_c = this.eventListeners.get('rotation')) === null || _c === void 0 ? void 0 : _c.forEach((listener) => {
+                listener(this.view ? this.view.viewRotation : 0);
+            });
+        }
+        if (args.visisblePageRangeChanged) {
+            (_d = this.eventListeners.get('firstVisiblePage')) === null || _d === void 0 ? void 0 : _d.forEach((listener) => {
+                listener(this.view ? this.view.firstVisiblePage : 0);
+            });
+            (_e = this.eventListeners.get('lastVisiblePage')) === null || _e === void 0 ? void 0 : _e.forEach((listener) => {
+                listener(this.view ? this.view.lastVisiblePage : 0);
+            });
+        }
+        if (args.pageNumberChanged) {
+            (_f = this.eventListeners.get('pageNumber')) === null || _f === void 0 ? void 0 : _f.forEach((listener) => {
+                listener(this.view ? this.view.pageNumber : 0);
+            });
+        }
+        if (args.zoomChanged) {
+            (_g = this.eventListeners.get('zoom')) === null || _g === void 0 ? void 0 : _g.forEach((listener) => {
+                listener(this.view ? this.view.zoom : 0);
+            });
+        }
+        // A ViewUpdatedEvent should always dispatch a
+        // CanvasInvalidated Event
+        (_h = this.eventListeners.get('canvasInvalidated')) === null || _h === void 0 ? void 0 : _h.forEach((listener) => {
+            listener(true);
+        });
+    }
+    onImageRemovedFromCache(id) {
+        const imgContainer = this.imageBitmapCache.get(id);
+        imgContainer === null || imgContainer === void 0 ? void 0 : imgContainer.destroy();
+        this.imageBitmapCache.delete(id);
+    }
+    onImageCreated(image) {
+        this.imageBitmapCache.set(image.id, new ImageContainer(image));
+        image.removeImageData();
+        image.close();
+    }
+    getProductVersion() {
+        return PdfViewing.Sdk.version;
+    }
+    getXDPI() {
+        var _a;
+        if (this.devicePixelRatio !== window.devicePixelRatio || this.xDPI === 0) {
+            const dpi = document.createElement('div');
+            dpi.style.height = '1in';
+            dpi.style.width = '1in';
+            dpi.style.visibility = 'hidden';
+            document.body.appendChild(dpi);
+            this.xDPI = window.devicePixelRatio * dpi.offsetWidth;
+            (_a = dpi.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(dpi);
+        }
+        return this.xDPI;
+    }
+    getYDPI() {
+        var _a;
+        if (this.devicePixelRatio !== window.devicePixelRatio || this.yDPI === 0) {
+            const dpi = document.createElement('div');
+            dpi.style.height = '1in';
+            dpi.style.width = '1in';
+            dpi.style.visibility = 'hidden';
+            document.body.appendChild(dpi);
+            this.yDPI = window.devicePixelRatio * dpi.offsetHeight;
+            (_a = dpi.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(dpi);
+        }
+        return this.yDPI;
+    }
+    ViewingPdfRect2WwPdfRect(rect) {
+        return {
+            pdfX: rect.x,
+            pdfY: rect.y,
+            pdfW: rect.width,
+            pdfH: rect.height,
+            page: rect.pageNumber,
+        };
+    }
+    ViewingQuadrilateral2WwPdfRect(quadrilateral) {
+        if (quadrilateral.bottomLeft && quadrilateral.bottomRight && quadrilateral.topLeft) {
+            const width = quadrilateral.bottomRight.x - quadrilateral.bottomLeft.x;
+            const height = quadrilateral.topLeft.y - quadrilateral.bottomLeft.y;
+            return {
+                pdfX: quadrilateral.bottomLeft.x,
+                pdfY: quadrilateral.bottomLeft.y,
+                pdfW: width,
+                pdfH: height,
+                page: quadrilateral.pageNumber,
+            };
+        }
+        return { page: -1, pdfX: -1, pdfY: -1, pdfW: -1, pdfH: -1 };
+    }
+    ViewingVPRect2WwVpRect(rect) {
+        return { x: rect.x, y: rect.y, w: rect.width, h: rect.height };
+    }
+}