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

package/es6/pdf-viewer-canvas/view-layers/AnnotationSelectionLayer.js

@@ -0,0 +1,452 @@
+import { PdfItemType, PdfItemCategory, PdfPageLayoutMode, } from '../../pdf-viewer-api';
+import { ViewLayerBase } from './ViewLayerBase';
+import { ViewerMode, copyTextToClipboard, CursorStyle } from '../state/viewer';
+import { createAnnotationContextBar } from './views/AnnotationContextBar';
+import { AnnotationBorder } from './views/AnnotationBorder';
+import { addHistoryEntry } from '../../custom/history';
+/** internal */
+export class AnnotationSelectionLayer extends ViewLayerBase {
+    constructor() {
+        super();
+        this.context = null;
+        this.selectedAnnotation = null;
+        this.selectionElement = null;
+        this.barAtTop = true;
+        this.contextBar = null;
+        this.annotationBorder = null;
+        this.deleteAnnotation = this.deleteAnnotation.bind(this);
+        this.rotateAnnotation = this.rotateAnnotation.bind(this);
+        this.copyAnnotationText = this.copyAnnotationText.bind(this);
+        this.createPopup = this.createPopup.bind(this);
+        this.openPopup = this.openPopup.bind(this);
+        this.deletePopup = this.deletePopup.bind(this);
+        this.moveAnnotation = this.moveAnnotation.bind(this);
+        this.toggleLock = this.toggleLock.bind(this);
+        this.resizeAnnotation = this.resizeAnnotation.bind(this);
+        this.onItemSelected = this.onItemSelected.bind(this);
+        this.onItemDblClick = this.onItemDblClick.bind(this);
+    }
+    create() {
+        var _a, _b;
+        if (this.viewerCanvas) {
+            this.viewerCanvas.addEventListener('itemSelected', this.onItemSelected);
+        }
+        this.selectAnnotation = this.selectAnnotation.bind(this);
+        this.deselectAnnotation = this.deselectAnnotation.bind(this);
+        this.deleteAnnotation = this.deleteAnnotation.bind(this);
+        this.createPopup = this.createPopup.bind(this);
+        this.deletePopup = this.deletePopup.bind(this);
+        this.openPopup = this.openPopup.bind(this);
+        this.context = this.createCanvas('pwv-annotation-selection-layers');
+        this.context.canvas.style.display = 'none';
+        this.selectionElement = this.createHtmlLayer();
+        this.selectionElement.style.display = 'none';
+        this.selectionElement.style.position = 'absolute';
+        this.selectionElement.classList.add('pwv-annotation-selection');
+        this.selectionElement.classList.add('pwv-contextbar-top');
+        this.selectionElement.addEventListener('click', (e) => {
+            e.preventDefault();
+            e.cancelBubble = true;
+        }, false);
+        if ((_a = this.viewerCanvas) === null || _a === void 0 ? void 0 : _a.licenseFeatures.annotate) {
+            this.contextBar = createAnnotationContextBar({
+                allowCopyText: this.options.viewer.permissions.allowCopyText,
+                allowLockAnnotations: this.options.viewer.permissions.allowLockAnnotations,
+                allowEditLockedAnnotations: this.options.viewer.permissions.allowEditLockedAnnotations,
+                onDeleteAnnotation: this.deleteAnnotation,
+                onRotateAnnotation: this.rotateAnnotation,
+                onCopy: this.copyAnnotationText,
+                onCreatePopup: this.createPopup,
+                onOpenPopup: this.openPopup,
+                onDeletePopup: this.deletePopup,
+                onToggleLock: this.toggleLock,
+            }, this.selectionElement);
+        }
+        this.annotationBorder = new AnnotationBorder(this.selectionElement, this.moveAnnotation, this.resizeAnnotation, this.onItemDblClick, this.options, this.store, !((_b = this.viewerCanvas) === null || _b === void 0 ? void 0 : _b.licenseFeatures.annotate) || false);
+    }
+    render(timestamp, state) {
+        const mode = state.viewer.mode;
+        if (this.selectedAnnotation && mode !== ViewerMode.ANNOTATION_SELECTED) {
+            this.deselectAnnotation();
+        }
+        const { pageLayoutMode } = state.document;
+        if ((pageLayoutMode === PdfPageLayoutMode.SINGLE_PAGE ||
+            pageLayoutMode === PdfPageLayoutMode.TWO_PAGE_LEFT ||
+            pageLayoutMode === PdfPageLayoutMode.TWO_PAGE_RIGHT) &&
+            this.selectedAnnotation &&
+            state.document.firstVisiblePageChanged) {
+            this.deselectAnnotation();
+            this.store.canvas.setCanvasInvalidated(true);
+            return false;
+        }
+        if ((state.pointer.action === 'click' || state.pointer.action === 'dblclick') &&
+            (mode === ViewerMode.DEFAULT ||
+                mode === ViewerMode.ANNOTATION_SELECTED ||
+                mode === ViewerMode.POPUP_SELECTED)) {
+            const annotationsOnPoint = this.pdfViewerApi.getAnnotationsOnPoint({
+                x: state.pointer.x.devicePixels,
+                y: state.pointer.y.devicePixels,
+            });
+            let breakRenderLoop = false;
+            if (annotationsOnPoint && annotationsOnPoint.length) {
+                // the most visible annotation is the last element of the returned list
+                for (let i = annotationsOnPoint.length - 1; i >= 0; i--) {
+                    const annotationOnPoint = annotationsOnPoint[i];
+                    if (annotationOnPoint.behaviors.selectable) {
+                        if (state.pointer.action === 'click') {
+                            if (annotationOnPoint.itemType === PdfItemType.WIDGET) {
+                                if (this.viewerCanvas && !annotationOnPoint.widget.readOnly) {
+                                    this.viewerCanvas.activateModule('FormFieldModule', {
+                                        annotationId: annotationOnPoint.id,
+                                        action: 'click',
+                                    });
+                                    breakRenderLoop = true;
+                                    break;
+                                }
+                            }
+                            else if (annotationOnPoint.id !== state.viewer.selectedAnnotationId) {
+                                if (state.viewer.selectedAnnotationId) {
+                                    this.deselectAnnotation();
+                                }
+                                if (!annotationOnPoint.isHidden()) {
+                                    this.selectAnnotation(annotationOnPoint);
+                                    breakRenderLoop = true;
+                                    break;
+                                }
+                            }
+                        }
+                        else if (state.pointer.action === 'dblclick') {
+                            this.onItemDblClick(annotationOnPoint.id);
+                            break;
+                        }
+                    }
+                }
+            }
+            else if (state.viewer.selectedAnnotationId) {
+                this.deselectAnnotation();
+                breakRenderLoop = true;
+            }
+            if (breakRenderLoop) {
+                this.store.canvas.setCanvasInvalidated(true);
+                return false;
+            }
+        }
+        if (mode === ViewerMode.ANNOTATION_SELECTED && state.viewer.selectedAnnotationId) {
+            const annotation = state.annotations.all[state.viewer.selectedAnnotationId];
+            if (this.selectedAnnotation === null) {
+                this.selectAnnotation(annotation);
+            }
+            if (this.annotationBorder && state.canvas.canvasInvalidated) {
+                const pageRect = state.document.pageRects[annotation.pdfRect.page];
+                if (pageRect) {
+                    this.annotationBorder.updatePageRect(pageRect);
+                }
+            }
+            if (state.viewer.selectedAnnotationChanged || state.canvas.canvasInvalidated) {
+                this.updateSelectionElementPosition(annotation);
+            }
+        }
+    }
+    updateSelectionElementPosition(annotation) {
+        if (this.selectionElement) {
+            const rect = this.pdfViewerApi.transformPdfPageRectToScreenRect(annotation.pdfRect);
+            const annotationY = rect.y / devicePixelRatio;
+            const annotationX = rect.x / devicePixelRatio;
+            const annotationW = rect.w / devicePixelRatio;
+            const annotationH = rect.h / devicePixelRatio;
+            const newBarAtTop = annotationY > 80;
+            this.selectionElement.style.top = annotationY + 'px';
+            this.selectionElement.style.left = annotationX + 'px';
+            this.selectionElement.style.width = annotationW + 'px';
+            this.selectionElement.style.height = annotationH + 'px';
+            if (this.barAtTop !== newBarAtTop) {
+                this.barAtTop = newBarAtTop;
+                if (this.barAtTop) {
+                    this.selectionElement.classList.remove('pwv-contextbar-bottom');
+                    this.selectionElement.classList.add('pwv-contextbar-top');
+                }
+                else {
+                    this.selectionElement.classList.remove('pwv-contextbar-top');
+                    this.selectionElement.classList.add('pwv-contextbar-bottom');
+                }
+            }
+            // update contextbar left position
+            const contextbarElement = this.selectionElement.lastChild;
+            if (contextbarElement && contextbarElement.nodeType === 1) {
+                const state = this.store.getState();
+                const canvasWidth = state.canvas.width.cssPixels;
+                const barWidth = contextbarElement.offsetWidth;
+                const barCenter = barWidth / 2;
+                const padding = 4;
+                let left = 0;
+                if (barWidth > annotationW) {
+                    left = (barWidth - annotationW) / -2;
+                }
+                else {
+                    left = (annotationW - barWidth) / 2;
+                }
+                if (annotationX + left + padding < 0) {
+                    left = annotationX * -1 + padding;
+                    if (annotationX + annotationW < barCenter) {
+                        left = annotationW - barCenter;
+                    }
+                }
+                if (annotationX + left + barWidth + padding > canvasWidth) {
+                    left = canvasWidth - annotationX - barWidth - padding;
+                    if (left * -1 > barCenter) {
+                        left = barCenter * -1;
+                    }
+                }
+                contextbarElement.style.left = left + 'px';
+            }
+        }
+    }
+    selectAnnotation(annotation, preventEvent) {
+        var _a, _b;
+        if (this.selectionElement && this.context && this.annotationBorder) {
+            this.selectedAnnotation = annotation;
+            const pageRect = this.store.getState().document.pageRects[annotation.pdfRect.page];
+            this.annotationBorder.deselectAnnotation();
+            this.annotationBorder.setAnnotation(annotation, pageRect);
+            const state = this.store.getState();
+            if (((_a = this.viewerCanvas) === null || _a === void 0 ? void 0 : _a.licenseFeatures.annotate) && this.contextBar) {
+                const commands = (_b = state.viewer.contextBarItems[annotation.itemType]) !== null && _b !== void 0 ? _b : [];
+                this.contextBar.setAnnotation({ annotation, commands });
+            }
+            this.context.canvas.style.display = 'none';
+            this.selectionElement.style.display = 'block';
+            this.barAtTop = true;
+            this.selectionElement.classList.remove('pwv-contextbar-bottom');
+            this.selectionElement.classList.add('pwv-contextbar-top');
+            this.updateSelectionElementPosition(annotation);
+            this.store.viewer.selectAnnotation(annotation);
+            this.store.viewer.setCursorStyle(CursorStyle.DEFAULT);
+            if (this.viewerCanvas && !preventEvent) {
+                this.dispatchEvent('itemSelected', annotation);
+            }
+        }
+    }
+    deselectAnnotation() {
+        if (this.context && this.selectionElement && this.annotationBorder) {
+            const annot = this.selectedAnnotation;
+            this.selectedAnnotation = null;
+            this.context.clearRect(0, 0, this.context.canvas.width, this.context.canvas.height);
+            this.annotationBorder.deselectAnnotation();
+            this.context.canvas.style.display = 'none';
+            this.selectionElement.style.display = 'none';
+            this.store.viewer.deselectAnnotation();
+            if (this.viewerCanvas && annot !== null) {
+                this.dispatchEvent('itemDeselected', annot);
+            }
+        }
+    }
+    rotateAnnotation(id) {
+        if (this.pdfViewerApi) {
+            const item = this.pdfViewerApi.getItem(id);
+            item.rotation = (item.rotation + 90) % 360;
+            this.pdfViewerApi.updateItem(item).then((item) => {
+                if (this.annotationBorder) {
+                    const annotation = item;
+                    const pageRect = this.store.getState().document.pageRects[annotation.pdfRect.page];
+                    this.annotationBorder.setAnnotation(annotation, pageRect);
+                }
+            });
+        }
+    }
+    moveAnnotation(id, point) {
+        var _a;
+        if (this.pdfViewerApi) {
+            const item = this.pdfViewerApi.getItem(id);
+            const newItemPos = this.pdfViewerApi.transformScreenPointToPdfPoint({
+                x: point.x * window.devicePixelRatio,
+                y: point.y * window.devicePixelRatio,
+            }, item.page, true);
+            if (newItemPos.pdfPoint.page === item.pdfRect.page) {
+                switch (this.pdfViewerApi.getRotation()) {
+                    case 0:
+                        item.pdfRect.pdfX = newItemPos.pdfPoint.pdfX;
+                        item.pdfRect.pdfY = newItemPos.pdfPoint.pdfY;
+                        break;
+                    case 90:
+                        item.pdfRect.pdfX = newItemPos.pdfPoint.pdfX - item.pdfRect.pdfW;
+                        item.pdfRect.pdfY = newItemPos.pdfPoint.pdfY;
+                        break;
+                    case 180:
+                        item.pdfRect.pdfX = newItemPos.pdfPoint.pdfX - item.pdfRect.pdfW;
+                        item.pdfRect.pdfY = newItemPos.pdfPoint.pdfY - item.pdfRect.pdfH;
+                        break;
+                    case 270:
+                        item.pdfRect.pdfX = newItemPos.pdfPoint.pdfX;
+                        item.pdfRect.pdfY = newItemPos.pdfPoint.pdfY - item.pdfRect.pdfH;
+                        break;
+                }
+            }
+            this.store.annotations.updateAnnotation(item);
+            this.store.canvas.setCanvasInvalidated(true);
+            if ((_a = this.viewerCanvas) === null || _a === void 0 ? void 0 : _a.licenseFeatures.annotate) {
+                this.pdfViewerApi.updateItem(item);
+            }
+        }
+    }
+    resizeAnnotation(id, rect) {
+        var _a;
+        if (this.pdfViewerApi) {
+            const item = this.pdfViewerApi.getItem(id);
+            const newItemRect = this.pdfViewerApi.transformScreenRectToPdfRect({
+                x: rect.x * window.devicePixelRatio,
+                y: rect.y * window.devicePixelRatio,
+                w: rect.w * window.devicePixelRatio,
+                h: rect.h * window.devicePixelRatio,
+            }, item.pdfRect.page);
+            if (newItemRect.page === item.pdfRect.page) {
+                item.pdfRect = newItemRect;
+            }
+            this.store.annotations.updateAnnotation(item);
+            this.store.canvas.setCanvasInvalidated(true);
+            if ((_a = this.viewerCanvas) === null || _a === void 0 ? void 0 : _a.licenseFeatures.annotate) {
+                this.pdfViewerApi.updateItem(item);
+            }
+        }
+    }
+    copyAnnotationText(id) {
+        if (this.pdfViewerApi) {
+            const item = this.pdfViewerApi.getItem(id);
+            if (item.itemType === PdfItemType.HIGHLIGHT ||
+                item.itemType === PdfItemType.UNDERLINE ||
+                item.itemType === PdfItemType.SQUIGGLY ||
+                item.itemType === PdfItemType.STRIKE_OUT) {
+                const quadPointAnnotation = item;
+                const firstRect = quadPointAnnotation.quadrilaterals[0];
+                const lastRect = quadPointAnnotation.quadrilaterals[quadPointAnnotation.quadrilaterals.length - 1];
+                const startPoint = {
+                    pdfX: firstRect.topLeft.x,
+                    pdfY: firstRect.topLeft.y,
+                    page: firstRect.pageNumber,
+                };
+                const endPoint = {
+                    pdfX: lastRect.bottomRight.x,
+                    pdfY: lastRect.bottomRight.y,
+                    page: lastRect.pageNumber,
+                };
+                const text = this.pdfViewerApi.getText(startPoint, endPoint);
+                copyTextToClipboard(text || '');
+            }
+        }
+    }
+    toggleLock(id) {
+        var _a;
+        if (((_a = this.viewerCanvas) === null || _a === void 0 ? void 0 : _a.licenseFeatures.annotate) && this.pdfViewerApi) {
+            const annot = this.pdfViewerApi.getItem(id);
+            if (this.options.annotation.trackHistory) {
+                addHistoryEntry(annot, annot.isLocked() ? 'unlock' : 'lock', this.options.viewer.general.user);
+            }
+            annot.setLock(!annot.isLocked());
+            if (this.annotationBorder) {
+                this.annotationBorder.deselectAnnotation();
+                const pageRect = this.store.getState().document.pageRects[annot.pdfRect.page];
+                this.annotationBorder.setAnnotation(annot, pageRect);
+            }
+            this.store.annotations.updateAnnotation(annot);
+            this.pdfViewerApi.updateItem(annot);
+        }
+    }
+    deleteAnnotation(id) {
+        var _a;
+        if (((_a = this.viewerCanvas) === null || _a === void 0 ? void 0 : _a.licenseFeatures.annotate) && this.pdfViewerApi) {
+            const item = this.pdfViewerApi.getItem(id);
+            if (this.options.annotation.hideOnDelete) {
+                item.setHidden(true);
+                item.popup.isOpen = false;
+                if (this.options.annotation.trackHistory) {
+                    addHistoryEntry(item, 'delete', this.options.viewer.general.user);
+                }
+                this.store.annotations.updateAnnotation(item);
+                this.pdfViewerApi.updateItem(item);
+                this.deselectAnnotation();
+            }
+            else {
+                this.pdfViewerApi
+                    .deleteItem(item)
+                    .then(() => {
+                    this.deselectAnnotation();
+                })
+                    .catch((error) => {
+                    console.error(error);
+                });
+            }
+        }
+    }
+    deletePopup(id) {
+        var _a;
+        if (((_a = this.viewerCanvas) === null || _a === void 0 ? void 0 : _a.licenseFeatures.annotate) && this.pdfViewerApi) {
+            const item = this.pdfViewerApi.getItem(id);
+            item.content = null;
+            item.popup.isOpen = false;
+            this.store.annotations.updateAnnotation(item);
+            this.store.canvas.setCanvasInvalidated(true);
+            this.pdfViewerApi.updateItem(item);
+        }
+    }
+    createPopup(id) {
+        var _a;
+        if (((_a = this.viewerCanvas) === null || _a === void 0 ? void 0 : _a.licenseFeatures.annotate) && this.pdfViewerApi) {
+            const item = this.pdfViewerApi.getItem(id);
+            item.content = '';
+            item.popup.isOpen = true;
+            item.popup.pdfRect.pdfX = item.pdfRect.pdfX;
+            item.popup.pdfRect.pdfY = item.pdfRect.pdfY - (item.popup.pdfRect.pdfH + 10);
+            this.store.annotations.updateAnnotation(item);
+            this.store.canvas.setCanvasInvalidated(true);
+            this.pdfViewerApi.updateItem(item).then(() => {
+                this.store.viewer.selectPopup({ id: item.id, focus: true });
+            });
+            this.deselectAnnotation();
+        }
+    }
+    openPopup(id) {
+        var _a, _b;
+        if (this.pdfViewerApi) {
+            const item = this.pdfViewerApi.getItem(id);
+            if (!((_a = this.viewerCanvas) === null || _a === void 0 ? void 0 : _a.licenseFeatures.annotate) && (!item.content || !item.content)) {
+                return;
+            }
+            if (!item.popup) {
+                return;
+            }
+            item.popup.isOpen = true;
+            this.store.annotations.updateAnnotation(item);
+            this.store.canvas.setCanvasInvalidated(true);
+            if ((_b = this.viewerCanvas) === null || _b === void 0 ? void 0 : _b.licenseFeatures.annotate) {
+                this.pdfViewerApi.updateItem(item).then(() => {
+                    this.store.viewer.selectPopup({ id: item.id, focus: true });
+                });
+            }
+            else {
+                this.deselectAnnotation();
+                this.store.viewer.selectPopup({ id: item.id, focus: true });
+            }
+        }
+    }
+    onItemDblClick(id) {
+        if (this.pdfViewerApi) {
+            const item = this.pdfViewerApi.getItem(id);
+            const { behaviors } = item;
+            if (item.isHidden()) {
+                return;
+            }
+            if (item.itemType === PdfItemType.FREE_TEXT && !item.isReadOnly() && !item.isLocked()) {
+                if (this.viewerCanvas) {
+                    this.viewerCanvas.activateModule('FreetextAnnotationModule', item.id);
+                }
+            }
+            else if (behaviors.canHavePopup && !item.isHidden()) {
+                this.openPopup(id);
+            }
+        }
+    }
+    onItemSelected(item) {
+        if (item.itemCategory === PdfItemCategory.ANNOTATION) {
+            this.selectAnnotation(item, true);
+        }
+    }
+}

package/es6/pdf-viewer-canvas/view-layers/BusyStateLayer.d.ts

@@ -0,0 +1,9 @@
+import { ViewLayerBase } from './ViewLayerBase';
+import { ViewerCanvasState } from '../state/store';
+/** internal */
+export declare class BusyStateLayer extends ViewLayerBase {
+    private busyStateView;
+    constructor();
+    create(): void;
+    render(timestamp: number, state: ViewerCanvasState): void;
+}

package/es6/pdf-viewer-canvas/view-layers/BusyStateLayer.js

@@ -0,0 +1,25 @@
+import { ViewLayerBase } from './ViewLayerBase';
+/** internal */
+export class BusyStateLayer extends ViewLayerBase {
+    constructor() {
+        super();
+    }
+    create() {
+        this.busyStateView = this.createHtmlLayer();
+        this.busyStateView.classList.add('pwv-BusyLoader');
+        this.busyStateView.style.display = 'none';
+        const ct = document.createElement('div');
+        this.busyStateView.appendChild(ct);
+        const rects = ['rect-1', 'rect-2', 'rect-3', 'rect-4', 'rect-5'];
+        rects.forEach((rect) => {
+            const rectElement = document.createElement('div');
+            rectElement.classList.add(rect);
+            ct.appendChild(rectElement);
+        });
+    }
+    render(timestamp, state) {
+        if (this.busyStateView && state.document.busyStateChanged) {
+            this.busyStateView.style.display = state.document.busyState ? 'block' : 'none';
+        }
+    }
+}

package/es6/pdf-viewer-canvas/view-layers/PdfDocumentLayer.d.ts

@@ -0,0 +1,10 @@
+import { ViewLayerBase } from './ViewLayerBase';
+import { ViewerCanvasState } from '../state/store';
+/** internal */
+export declare class PdfDocumentLayer extends ViewLayerBase {
+    context: CanvasRenderingContext2D | null | undefined;
+    private canvas;
+    constructor();
+    create(): void;
+    render(timestamp: number, state: ViewerCanvasState): void;
+}

package/es6/pdf-viewer-canvas/view-layers/PdfDocumentLayer.js

@@ -0,0 +1,149 @@
+import { PdfItemType, PdfActionType, } from '../../pdf-viewer-api';
+import { ViewLayerBase } from './ViewLayerBase';
+import { ViewerMode, CursorStyle } from '../state/viewer';
+import { renderTextSelection } from './canvasShapes';
+/** internal */
+export class PdfDocumentLayer extends ViewLayerBase {
+    constructor() {
+        super();
+    }
+    create() {
+        this.context = this.createCanvas();
+        this.canvas = this.context.canvas;
+    }
+    render(timestamp, state) {
+        if (this.pdfViewerApi) {
+            const draw = state.canvas.canvasInvalidated ||
+                state.canvas.widthChanged ||
+                state.canvas.heightChanged ||
+                state.viewer.modeChanged ||
+                state.viewer.textSelectionChanged ||
+                state.pointer.stateChanged ||
+                !state.search.painted;
+            const defaultState = state.viewer.mode === ViewerMode.DEFAULT;
+            // set cursor style and handle link click
+            if (defaultState && (state.pointer.positionChanged || state.pointer.stateChanged)) {
+                const pointerPos = {
+                    x: state.pointer.x.devicePixels,
+                    y: state.pointer.y.devicePixels,
+                };
+                const pointerPdfPos = this.pdfViewerApi.transformScreenPointToPdfPoint(pointerPos);
+                this.store.viewer.setCursorStyle(CursorStyle.DEFAULT);
+                if (pointerPdfPos.isOnPage) {
+                    const annotationsOnPoint = this.pdfViewerApi.getAnnotationsOnPoint(pointerPos);
+                    const annotationOnPoint = annotationsOnPoint
+                        ? annotationsOnPoint[annotationsOnPoint.length - 1]
+                        : null;
+                    if (annotationOnPoint) {
+                        const itemType = annotationOnPoint.itemType;
+                        if ((itemType === PdfItemType.HIGHLIGHT ||
+                            itemType === PdfItemType.SQUIGGLY ||
+                            itemType === PdfItemType.STRIKE_OUT) &&
+                            this.pdfViewerApi.getTextFragmentOnPoint(pointerPos) !== null) {
+                            this.store.viewer.setCursorStyle(CursorStyle.TEXT);
+                        }
+                        else if (itemType === PdfItemType.LINK) {
+                            const link = annotationOnPoint;
+                            if ((link.destination && link.actionType === PdfActionType.GO_TO) ||
+                                (link.uri &&
+                                    link.actionType === PdfActionType.URI &&
+                                    this.options.viewer.permissions.allowExternalLinks)) {
+                                this.store.viewer.setCursorStyle(CursorStyle.POINTER);
+                            }
+                            if (state.pointer.action === 'click') {
+                                if (link.destination && link.actionType === PdfActionType.GO_TO) {
+                                    this.pdfViewerApi.goTo(link.destination);
+                                }
+                                else if (link.uri &&
+                                    link.actionType === PdfActionType.URI &&
+                                    this.options.viewer.permissions.allowExternalLinks) {
+                                    window.open(link.uri, undefined, 'noreferrer');
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        const textFragmentOnPoint = this.pdfViewerApi.getTextFragmentOnPoint(pointerPos);
+                        if (textFragmentOnPoint) {
+                            this.store.viewer.setCursorStyle(CursorStyle.TEXT);
+                        }
+                    }
+                }
+            }
+            if (draw) {
+                const ctx = this.context;
+                ctx.save();
+                const { pageShadow, currentPageShadow } = this.options.viewer.general;
+                // draw pdf
+                if (state.viewer.mode === ViewerMode.MODULE_SELECTED) {
+                    ctx.globalAlpha = 0.75;
+                    this.pdfViewerApi.renderCanvas(ctx, { pageShadow, currentPageShadow });
+                    ctx.globalAlpha = 1;
+                    ctx.fillStyle = 'rgb(255,255,255)';
+                    ctx.globalCompositeOperation = 'destination-over';
+                    for (const k in state.document.pageRects) {
+                        if (state.document.pageRects[k]) {
+                            const pageRect = state.document.pageRects[k];
+                            ctx.fillRect(pageRect.x, pageRect.y, pageRect.w, pageRect.h);
+                        }
+                    }
+                }
+                else {
+                    this.pdfViewerApi.renderCanvas(ctx, { pageShadow, currentPageShadow });
+                }
+                ctx.restore();
+                if (state.search.match) {
+                    ctx.save();
+                    ctx.globalCompositeOperation = 'multiply';
+                    ctx.fillStyle = this.options.viewer.general.searchMatchColor;
+                    ctx.globalAlpha = 0.9;
+                    ctx.beginPath();
+                    state.search.match.forEach((match) => {
+                        if (match.pageNumber >= state.document.firstVisiblePage &&
+                            match.pageNumber <= state.document.lastVisiblePage) {
+                            const path = this.pdfViewerApi.transformQuadrilateralToViewport(match);
+                            for (let k = 0; k < path.length; k++) {
+                                const point = path[k];
+                                if (k === 0) {
+                                    ctx.moveTo(point.x, point.y);
+                                }
+                                else {
+                                    ctx.lineTo(point.x, point.y);
+                                }
+                            }
+                        }
+                    });
+                    ctx.closePath();
+                    ctx.fill();
+                    ctx.restore();
+                }
+                this.store.search.matchPainted();
+                if (state.viewer.textSelection) {
+                    ctx.save();
+                    const selection = state.viewer.textSelection;
+                    const screenSelection = [];
+                    for (let i = 0; i < selection.quadrilaterals.length; i++) {
+                        const path = this.pdfViewerApi.transformQuadrilateralToViewport(selection.quadrilaterals[i]);
+                        screenSelection.push(path);
+                    }
+                    renderTextSelection(ctx, devicePixelRatio * state.document.zoom, this.options.viewer.general.textSelectionColor, screenSelection);
+                    ctx.restore();
+                    if (state.pointer.isDown &&
+                        state.viewer.textSelectionState === 'selecting' &&
+                        state.viewer.textSelectionType === 'rectangular') {
+                        const { textSelection } = state.viewer;
+                        const startPoint = this.pdfViewerApi.transformPdfPointToScreenPoint(textSelection.startPoint);
+                        const endPoint = this.pdfViewerApi.transformPdfPointToScreenPoint(textSelection.endPoint);
+                        ctx.save();
+                        const lineWidth = 2 * devicePixelRatio;
+                        ctx.lineWidth = lineWidth;
+                        ctx.setLineDash([lineWidth, lineWidth]);
+                        ctx.strokeStyle = this.options.viewer.general.textSelectionColor;
+                        ctx.strokeRect(startPoint.x, startPoint.y, endPoint.x - startPoint.x, endPoint.y - startPoint.y);
+                        ctx.restore();
+                    }
+                }
+            }
+        }
+    }
+}