| blob | 3f81155d181f1202ee8781e1c2194bbeb287adfb |
1 /**
2 * @licstart The following is the entire license notice for the
3 * Javascript code in this page
4 *
5 * Copyright 2021 Mozilla Foundation
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 * @licend The above is the entire license notice for the
20 * Javascript code in this page
21 */
27 /* 1 */
34 }));
44 };
47 cursorToolOnLoad: {
50 },
51 defaultUrl: {
54 },
55 defaultZoomValue: {
58 },
59 disableHistory: {
62 },
63 disablePageLabels: {
66 },
67 enablePermissions: {
70 },
71 enablePrintAutoRotate: {
74 },
75 enableScripting: {
78 },
79 externalLinkRel: {
82 },
83 externalLinkTarget: {
86 },
87 historyUpdateUrl: {
90 },
91 ignoreDestinationZoom: {
94 },
95 imageResourcesPath: {
98 },
99 maxCanvasPixels: {
103 },
104 pdfBugEnabled: {
107 },
108 printResolution: {
111 },
112 renderer: {
115 },
116 renderInteractiveForms: {
119 },
120 sidebarViewOnLoad: {
123 },
124 scrollModeOnLoad: {
127 },
128 spreadModeOnLoad: {
131 },
132 textLayerMode: {
135 },
136 useOnlyCssZoom: {
139 },
140 viewerCssTheme: {
143 },
144 viewOnLoad: {
147 },
148 cMapPacked: {
151 },
152 cMapUrl: {
155 },
156 disableAutoFetch: {
159 },
160 disableFontFace: {
163 },
164 disableRange: {
167 },
168 disableStream: {
171 },
172 docBaseUrl: {
175 },
176 enableXfa: {
179 },
180 fontExtraProperties: {
183 },
184 isEvalSupported: {
187 },
188 maxImageSize: {
191 },
192 pdfBug: {
195 },
196 standardFontDataUrl: {
199 },
200 verbosity: {
203 },
204 workerPort: {
207 },
208 workerSrc: {
211 }
212 };
213 {
217 };
221 };
225 };
227 }
233 }
240 }
246 }
249 }
260 }
266 if (valueType === "boolean" || valueType === "string" || valueType === "number" && Number.isInteger(value)) {
269 }
272 }
273 }
276 options[name] = userOption !== undefined ? userOption : defaultOption.compatibility ?? defaultOption.value;
277 }
280 }
284 }
289 }
290 }
294 }
296 }
301 /* 2 */
308 }));
311 {
316 const isIOS = /\b(iPad|iPhone|iPod)(?=;)/.test(userAgent) || platform === "MacIntel" && maxTouchPoints > 1;
322 }
323 })();
328 }
329 })();
330 }
335 /* 3 */
342 }));
343 exports.PDFViewerApplication = exports.PDFPrintServiceFactory = exports.DefaultExternalServices = void 0;
404 };
409 };
410 const KNOWN_VERSIONS = ["1.0", "1.1", "1.2", "1.3", "1.4", "1.5", "1.6", "1.7", "1.8", "1.9", "2.0", "2.1", "2.2", "2.3"];
411 const KNOWN_GENERATORS = ["acrobat distiller", "acrobat pdfwriter", "adobe livecycle", "adobe pdf library", "adobe photoshop", "ghostscript", "tcpdf", "cairo", "dvipdfm", "dvips", "pdftex", "pdfkit", "itext", "prince", "quarkxpress", "mac os x", "microsoft", "openoffice", "oracle", "luradocument", "pdf-xchange", "antenna house", "aspose.cells", "fpdf"];
416 }
430 }
434 }
438 }
442 }
446 }
450 }
456 });
457 }
461 }
463 }
521 if (this.isViewerEmbedded && _app_options.AppOptions.get("externalLinkTarget") === _pdfjsLib.LinkTarget.NONE) {
523 }
532 });
533 });
536 },
541 }
547 }
548 },
553 }
559 }
562 waitOn = [];
566 }
570 }
574 }
578 }
582 }
586 }
590 }
605 }
606 }
615 }
619 }
623 }
627 });
628 },
633 });
636 },
641 if (cssTheme === ViewerCssTheme.AUTOMATIC || !Object.values(ViewerCssTheme).includes(cssTheme)) {
643 }
650 const mediaRegex = new RegExp(`^@media \\(${mediaMatcher}: dark\\) {\\n\\s*([\\w\\s-.,:;/\\\\{}()]+)\\n}$`);
659 }
666 }
669 }
670 }
673 }
674 },
680 });
687 eventBus,
691 });
697 eventBus
698 });
701 eventBus,
705 });
710 container,
711 viewer,
712 eventBus,
715 downloadManager,
716 findController,
727 });
733 eventBus,
737 });
741 eventBus
742 });
747 }
749 this.pdfDocumentProperties = new _pdf_document_properties.PDFDocumentProperties(appConfig.documentProperties, this.overlayManager, eventBus, this.l10n);
751 container,
752 eventBus,
754 });
756 this.secondaryToolbar = new _secondary_toolbar.SecondaryToolbar(appConfig.secondaryToolbar, container, eventBus);
760 container,
762 eventBus
763 });
764 }
766 this.passwordPrompt = new _password_prompt.PasswordPrompt(appConfig.passwordOverlay, this.overlayManager, this.l10n, this.isViewerEmbedded);
769 eventBus,
770 linkService: pdfLinkService
771 });
774 eventBus,
775 downloadManager
776 });
779 eventBus,
781 });
786 eventBus,
788 });
790 this.pdfSidebarResizer = new _pdf_sidebar_resizer.PDFSidebarResizer(appConfig.sidebarResizer, eventBus, this.l10n);
791 },
795 },
799 },
803 },
808 }
819 },
824 }
835 },
840 }
843 },
847 },
851 },
855 },
859 },
863 let support = !!(doc.requestFullscreen || doc.mozRequestFullScreen || doc.webkitRequestFullScreen);
865 if (document.fullscreenEnabled === false || document.mozFullScreenEnabled === false || document.webkitFullscreenEnabled === false) {
867 }
870 },
874 },
878 },
883 },
887 },
891 },
903 }
904 }
907 },
912 }
915 },
919 },
924 }
928 }
931 },
937 container
943 }
949 });
951 }
963 }
989 }
993 }
1000 }
1003 },
1008 }
1014 }
1026 }
1036 }
1041 }
1042 }
1051 };
1054 loaded,
1055 total
1056 }) => {
1058 };
1066 }
1076 }
1081 });
1084 });
1085 });
1086 },
1091 }
1094 },
1098 } = {}) {
1108 });
1112 }
1113 },
1117 } = {}) {
1120 }
1133 });
1137 sourceEventType
1138 });
1142 }
1143 },
1150 }
1151 },
1156 featureId
1157 });
1161 }
1165 featureId,
1170 }
1174 });
1175 });
1176 },
1182 },
1188 })];
1193 }));
1198 }));
1203 }));
1204 }
1209 }));
1210 }
1211 }
1212 }
1223 };
1234 };
1240 };
1249 });
1250 },
1255 }
1261 const disableAutoFetch = this.pdfDocument ? this.pdfDocument.loadingParams.disableAutoFetch : _app_options.AppOptions.get("disableAutoFetch");
1267 }
1274 }
1275 }
1276 },
1281 length
1282 }) => {
1289 });
1290 });
1291 });
1304 firstPagePromise,
1305 onePageRendered,
1306 pagesPromise
1310 const storedPromise = (this.store = new _view_history.ViewHistory(pdfDocument.fingerprints[0])).getMultiple({
1321 });
1327 Promise.all([_ui_utils.animationStarted, storedPromise, pageLayoutPromise, pageModePromise, openActionPromise]).then(async ([timeStamp, stored, pageLayout, pageMode, openAction]) => {
1332 viewOnLoad,
1334 });
1350 hash = `page=${stored.page}&zoom=${zoom || stored.zoom},` + `${stored.scrollLeft},${stored.scrollTop}`;
1355 }
1359 }
1363 }
1364 }
1368 }
1372 }
1375 rotation,
1376 sidebarView,
1377 scrollMode,
1378 spreadMode
1379 });
1382 });
1386 }
1392 })]);
1396 }
1400 }
1409 });
1410 });
1415 });
1420 }
1423 outline,
1424 pdfDocument
1425 });
1426 });
1430 }
1433 attachments
1434 });
1435 });
1439 }
1442 optionalContentConfig,
1443 pdfDocument
1444 });
1445 });
1452 }, {
1454 });
1457 }
1458 });
1463 },
1470 });
1471 });
1475 }
1476 }
1482 });
1483 });
1487 }
1488 }
1498 };
1499 },
1506 }
1511 tagged
1512 });
1513 },
1516 const [openAction, javaScript] = await Promise.all([openActionPromise, !this.pdfViewer.enableScripting ? pdfDocument.getJavaScript() : null]);
1520 }
1526 }
1532 }
1537 });
1544 }
1545 }
1546 }
1547 }
1551 }
1552 },
1556 info,
1557 metadata,
1558 contentDispositionFilename,
1559 contentLength
1564 }
1568 this._contentDispositionFilename ?? (this._contentDispositionFilename = contentDispositionFilename);
1570 console.log(`PDF ${pdfDocument.fingerprints[0]} [${info.PDFFormatVersion} ` + `${(info.Producer || "-").trim()} / ${(info.Creator || "-").trim()}] ` + `(PDF.js: ${_pdfjsLib.version || "-"})`);
1577 }
1578 }
1584 }
1589 } else if ((info.IsAcroFormPresent || info.IsXFAPresent) && !this.pdfViewer.renderInteractiveForms) {
1592 }
1597 }
1603 }
1612 }
1616 });
1617 }
1625 }
1631 formType
1632 });
1635 });
1636 },
1643 }
1647 }
1652 console.error("The number of Page Labels does not match the number of pages in the document.");
1654 }
1659 i++;
1660 }
1664 }
1667 pdfViewer,
1668 pdfThumbnailViewer,
1669 toolbar
1675 },
1678 fingerprint,
1679 viewOnLoad,
1681 }) {
1684 }
1687 fingerprint,
1690 });
1695 }
1702 });
1703 }
1704 },
1711 }
1715 }
1719 }
1720 },
1725 }
1728 annotationStorage
1734 };
1739 };
1740 },
1743 rotation,
1744 sidebarView,
1745 scrollMode,
1746 spreadMode
1747 } = {}) {
1751 }
1752 };
1757 }
1761 }
1762 };
1776 }
1783 }
1784 },
1789 }
1794 },
1800 },
1807 }
1812 });
1814 }
1819 });
1821 }
1829 const printService = PDFPrintServiceFactory.instance.createPrintService(this.pdfDocument, pagesOverview, printContainer, printResolution, optionalContentConfigPromise, this.l10n);
1835 });
1836 },
1847 }
1848 }
1851 },
1855 },
1860 }
1863 },
1868 }
1871 },
1875 eventBus,
1876 _boundEvents
1963 }
1968 },
1972 eventBus,
1973 _boundEvents
1978 source: window
1979 });
1980 };
1986 });
1987 };
1991 source: window
1992 });
1993 };
1997 source: window
1998 });
1999 };
2005 });
2006 };
2011 });
2014 });
2022 },
2026 eventBus,
2027 _boundEvents
2112 }
2120 },
2124 _boundEvents
2129 });
2132 });
2145 },
2150 }
2153 const wholeTicks = Math.sign(this._wheelUnusedTicks) * Math.floor(Math.abs(this._wheelUnusedTicks));
2156 },
2161 }
2164 },
2168 }
2170 };
2177 }
2180 }
2189 });
2190 }
2193 pageNumber
2194 }) {
2197 }
2204 }
2207 }
2228 }
2235 }
2240 });
2241 });
2245 });
2252 }
2257 });
2258 });
2265 });
2266 }
2271 }
2276 }
2280 }
2286 });
2287 }
2295 });
2296 }
2297 }
2302 }
2303 }
2307 appConfig
2312 }
2315 }
2318 pageNumber,
2319 timestamp,
2320 error
2321 }) {
2324 }
2332 }
2333 }
2338 });
2339 }
2343 timestamp
2344 });
2348 stats
2349 });
2350 });
2351 }
2354 mode
2355 }) {
2383 }
2386 }
2397 }
2408 }
2409 }
2413 }
2416 PDFViewerApplication.pdfRenderingQueue.isThumbnailViewEnabled = PDFViewerApplication.pdfSidebar.isThumbnailViewVisible;
2421 }
2422 }
2436 }
2444 }
2451 }
2452 }
2459 }
2460 }
2464 pdfDocument,
2465 pdfViewer
2470 }
2474 if (currentScaleValue === "auto" || currentScaleValue === "page-fit" || currentScaleValue === "page-width") {
2476 }
2479 }
2486 }
2492 }
2493 }
2496 {
2500 }
2508 url = {
2509 url,
2511 };
2512 }
2522 };
2525 }
2532 };
2537 };
2538 }
2542 }
2546 }
2551 });
2552 }
2557 });
2558 }
2563 }
2564 }
2569 }
2570 }
2574 }
2578 }
2582 }
2586 }
2590 }
2597 }
2599 if (evt.value !== pdfViewer.currentPageNumber.toString() && evt.value !== pdfViewer.currentPageLabel) {
2600 PDFViewerApplication.toolbar.setPageNumber(pdfViewer.currentPageNumber, pdfViewer.currentPageLabel);
2601 }
2602 }
2606 }
2610 }
2614 }
2618 }
2622 }
2626 }
2630 }
2640 });
2641 }
2651 });
2652 }
2655 matchesCount
2656 }) {
2661 }
2662 }
2665 state,
2666 previous,
2667 matchesCount,
2668 rawQuery
2669 }) {
2674 matchesCount,
2675 rawQuery
2676 });
2679 }
2680 }
2685 }
2691 }
2694 pageNumber,
2695 pageLabel
2696 }) {
2702 }
2703 }
2708 }
2709 }
2716 }
2721 }
2725 pdfViewer,
2726 supportedMouseWheelZoomModifierKeys
2731 }
2733 if (evt.ctrlKey && supportedMouseWheelZoomModifierKeys.ctrlKey || evt.metaKey && supportedMouseWheelZoomModifierKeys.metaKey) {
2738 }
2744 if (evt.deltaMode === WheelEvent.DOM_DELTA_LINE || evt.deltaMode === WheelEvent.DOM_DELTA_PAGE) {
2749 }
2753 }
2759 }
2770 }
2773 }
2774 }
2779 }
2780 }
2785 }
2789 if (PDFViewerApplication.pdfViewer.containsElement(evt.target) || appConfig.toolbar.container.contains(evt.target) && evt.target !== appConfig.secondaryToolbar.toggleButton) {
2791 }
2792 }
2797 }
2801 const cmd = (evt.ctrlKey ? 1 : 0) | (evt.altKey ? 2 : 0) | (evt.shiftKey ? 4 : 0) | (evt.metaKey ? 8 : 0);
2811 }
2827 });
2828 }
2831 }
2841 }
2851 }
2861 });
2863 }
2872 }
2877 if (isViewerInPresentationMode || PDFViewerApplication.page < PDFViewerApplication.pagesCount) {
2881 }
2884 }
2885 }
2888 eventBus
2895 source: window
2896 });
2901 {
2903 source: window
2904 });
2906 }
2908 }
2909 }
2922 }
2923 }
2928 }
2932 }
2937 if (curElementTagName === "INPUT" || curElementTagName === "TEXTAREA" || curElementTagName === "SELECT" || curElement?.isContentEditable) {
2940 }
2941 }
2952 }
2960 }
2968 }
2979 }
2984 }
2992 }
3001 }
3009 }
3021 }
3026 if (isViewerInPresentationMode || PDFViewerApplication.page < PDFViewerApplication.pagesCount) {
3030 }
3049 }
3056 }
3059 }
3060 }
3068 }
3072 }
3080 }
3081 }
3084 if (evt.keyCode >= 33 && evt.keyCode <= 40 || evt.keyCode === 32 && curElementTagName !== "BUTTON") {
3086 }
3087 }
3091 }
3095 }
3096 }
3102 }
3105 instance: {
3110 }
3112 }
3113 };
3117 /* 4 */
3124 }));
3147 exports.WaitOnType = exports.VERTICAL_PADDING = exports.UNKNOWN_SCALE = exports.TextLayerMode = exports.SpreadMode = exports.SidebarView = exports.ScrollMode = exports.SCROLLBAR_PADDING = exports.RendererType = exports.ProgressBar = exports.PresentationModeState = exports.MIN_SCALE = exports.MAX_SCALE = exports.MAX_AUTO_SCALE = exports.EventBus = exports.DEFAULT_SCALE_VALUE = exports.DEFAULT_SCALE = exports.CSS_UNITS = exports.AutoPrintRegExp = exports.animationStarted = void 0;
3172 };
3181 };
3186 };
3192 };
3199 };
3206 };
3213 const backingStoreRatio = ctx.webkitBackingStorePixelRatio || ctx.mozBackingStorePixelRatio || ctx.backingStorePixelRatio || 1;
3219 };
3220 }
3228 }
3233 while (parent.clientHeight === parent.scrollHeight && parent.clientWidth === parent.scrollWidth || scrollMatches && (parent.classList.contains("markedContent") || getComputedStyle(parent).overflow === "hidden")) {
3240 }
3241 }
3246 }
3251 }
3252 }
3255 }
3261 }
3270 }
3278 }
3282 });
3283 };
3290 _eventHandler: debounceScroll
3291 };
3295 }
3306 }
3309 }
3317 }
3321 }
3331 }
3332 }
3335 }
3340 }
3349 }
3363 }
3371 }
3372 }
3380 }
3383 }
3388 }
3391 view,
3392 userUnit,
3393 rotate
3394 }) {
3402 };
3403 }
3408 }
3416 }
3423 }
3426 }
3429 }
3432 scrollEl,
3433 views,
3437 }) {
3447 }
3454 }
3458 let firstVisibleElementInd = binarySearchFirstItem(views, horizontal ? isElementNextAfterViewHorizontally : isElementBottomAfterViewTop);
3461 firstVisibleElementInd = backtrackBeforeAllVisibleElements(firstVisibleElementInd, views, top);
3462 }
3479 }
3482 }
3484 if (viewBottom <= top || currentHeight >= bottom || viewRight <= left || currentWidth >= right) {
3486 }
3497 view,
3498 percent,
3500 });
3501 }
3512 }
3515 });
3516 }
3519 first,
3520 last,
3521 views: visible
3522 };
3523 }
3527 }
3535 }
3538 }
3551 }
3554 }
3558 }
3561 return Number.isInteger(mode) && Object.values(ScrollMode).includes(mode) && mode !== ScrollMode.UNKNOWN;
3562 }
3565 return Number.isInteger(mode) && Object.values(SpreadMode).includes(mode) && mode !== SpreadMode.UNKNOWN;
3566 }
3570 }
3575 };
3579 target,
3580 name,
3582 }) {
3584 if (typeof target !== "object" || !(name && typeof name === "string") || !(Number.isInteger(delay) && delay >= 0)) {
3586 }
3593 }
3597 }
3600 }
3608 }
3612 });
3613 }
3617 });
3622 }
3627 }
3633 });
3634 }
3640 });
3641 }
3648 }
3654 listener,
3655 external,
3656 once
3660 }
3665 }
3668 }
3673 }
3676 }
3677 }
3682 const eventListeners = (_this$_listeners = this._listeners)[eventName] || (_this$_listeners[eventName] = []);
3684 listener,
3687 });
3688 }
3695 }
3701 }
3702 }
3703 }
3705 }
3711 }
3715 height,
3716 width,
3717 units
3718 } = {}) {
3727 }
3734 }
3739 }
3743 }
3750 }
3755 }
3763 }
3764 }
3769 }
3773 }
3778 }
3782 }
3784 }
3799 }
3800 }
3804 }
3805 }
3814 }
3817 }
3832 }
3835 }
3853 }
3856 }
3859 /* 5 */
3870 }
3875 /* 6 */
3882 }));
3893 };
3898 container,
3899 eventBus,
3901 }) {
3908 });
3914 });
3915 }
3919 }
3924 }
3928 }
3940 }
3941 };
3957 }
3962 }
3968 });
3969 }
3974 });
3979 {
3984 }
3987 {
3992 }
3993 }
3994 });
3995 }
3997 }
4002 /* 7 */
4009 }));
4018 }
4029 }
4041 }
4042 }
4043 },
4055 }
4056 }
4057 },
4063 }
4064 },
4067 },
4071 }
4078 }
4079 }
4094 }
4095 },
4103 }
4115 });
4119 }
4123 }
4124 },
4130 }
4131 };
4136 }
4140 const isSafari6plus = /Apple/.test(navigator.vendor) && /Version\/([6-9]\d*|[1-5]\d+)/.test(navigator.userAgent);
4144 }
4147 }
4150 /* 8 */
4157 }));
4168 };
4180 }
4184 }
4188 }
4192 }
4198 }
4202 }
4207 }
4208 }
4212 }
4216 }
4217 }
4225 }
4232 }
4233 }
4240 }
4246 }
4247 }
4250 }
4254 }
4277 }
4280 });
4282 }
4285 }
4287 }
4292 /* 9 */
4299 }));
4307 }
4311 }
4320 }
4323 element,
4324 container,
4325 callerCloseMethod,
4326 canForceClose
4327 };
4328 }
4335 }
4338 }
4350 }
4351 }
4360 }
4369 }
4377 }
4384 }
4385 }
4390 }
4394 }
4395 }
4397 }
4402 /* 10 */
4409 }));
4432 }
4433 });
4435 }
4443 }
4445 this.label.textContent = await this.l10n.get(`password_${passwordIncorrect ? "invalid" : "label"}`);
4446 }
4451 });
4452 }
4460 }
4461 }
4466 }
4468 }
4473 /* 11 */
4480 }));
4493 }
4501 }
4505 }
4508 }
4516 }
4523 });
4525 });
4527 }
4531 attachmentsCount
4532 });
4533 }
4536 content,
4537 filename
4538 }) {
4542 };
4543 }
4546 attachments,
4548 }) {
4551 }
4559 }
4563 });
4576 content,
4577 filename
4578 });
4583 attachmentsCount++;
4584 }
4587 }
4590 id,
4591 filename,
4592 content
4593 }) {
4598 }
4608 }
4609 }
4610 }
4613 filename,
4614 content
4615 };
4617 attachments,
4619 });
4620 });
4621 }
4623 }
4628 /* 12 */
4635 }));
4647 }
4652 }
4660 }
4664 }
4668 }
4672 }
4680 }
4690 }
4691 };
4694 }
4701 }
4702 }
4706 }
4712 }
4717 }
4721 }
4728 }
4733 }
4734 }
4739 }
4747 }
4750 }
4755 }
4757 }
4762 /* 13 */
4769 }));
4781 };
4785 };
4791 }
4795 overlayName,
4796 fields,
4797 container,
4798 closeButton
4813 });
4817 });
4822 });
4823 }
4832 });
4833 };
4835 await Promise.all([this.overlayManager.open(this.overlayName), this._dataAvailableCapability.promise]);
4839 if (this.fieldData && currentPageNumber === this.fieldData._currentPageNumber && pagesRotation === this.fieldData._pagesRotation) {
4843 }
4846 info,
4847 contentDispositionFilename,
4848 contentLength
4850 const [fileName, fileSize, creationDate, modificationDate, pageSize, isLinearized] = await Promise.all([contentDispositionFilename || (0, _pdfjsLib.getPdfFilenameFromUrl)(this.url), this._parseFileSize(contentLength), this._parseDate(info.CreationDate), this._parseDate(info.ModDate), this.pdfDocument.getPage(currentPageNumber).then(pdfPage => {
4854 fileName,
4855 fileSize,
4860 creationDate,
4861 modificationDate,
4866 pageSize,
4869 _pagesRotation: pagesRotation
4870 });
4875 length
4880 }
4887 }
4891 }
4898 }
4902 }
4908 }
4917 }
4923 }
4926 }
4930 }
4935 }
4936 }
4944 }
4950 });
4951 }
4956 }
4959 pageSizeInches = {
4962 };
4963 }
4969 };
4973 };
4974 let rawName = getPageName(sizeInches, isPortrait, US_PAGE_NAMES) || getPageName(sizeMillimeters, isPortrait, METRIC_PAGE_NAMES);
4976 if (!rawName && !(Number.isInteger(sizeMillimeters.width) && Number.isInteger(sizeMillimeters.height))) {
4980 };
4984 };
4986 if (Math.abs(exactMillimeters.width - intMillimeters.width) < 0.1 && Math.abs(exactMillimeters.height - intMillimeters.height) < 0.1) {
4990 sizeInches = {
4993 };
4995 }
4996 }
4997 }
5000 width,
5001 height
5002 }, unit, name, orientation] = await Promise.all([this._isNonMetricLocale ? sizeInches : sizeMillimeters, this.l10n.get(`document_properties_page_size_unit_${this._isNonMetricLocale ? "inches" : "millimeters"}`), rawName && this.l10n.get(`document_properties_page_size_name_${rawName.toLowerCase()}`), this.l10n.get(`document_properties_page_size_orientation_${isPortrait ? "portrait" : "landscape"}`)]);
5006 unit,
5007 name,
5008 orientation
5009 });
5010 }
5017 }
5022 });
5023 }
5027 }
5029 }
5034 /* 14 */
5041 }));
5065 });
5068 });
5074 }
5081 }
5082 });
5085 });
5088 });
5091 });
5094 });
5097 });
5100 }
5104 }
5109 type,
5115 findPrevious: findPrev
5116 });
5117 }
5139 }
5146 });
5148 }
5153 } = {}) {
5161 limit
5162 });
5166 current,
5167 total
5168 });
5169 }
5170 }
5177 });
5178 }
5186 }
5192 }
5197 }
5205 });
5206 }
5213 }
5214 }
5219 }
5227 }
5228 }
5230 }
5235 /* 15 */
5242 }));
5256 };
5274 };
5281 }
5290 }
5293 });
5295 }
5300 }
5309 }
5314 }
5317 }
5320 }
5324 linkService,
5325 eventBus
5326 }) {
5333 }
5337 }
5341 }
5345 }
5349 }
5353 }
5358 }
5362 }
5367 }
5372 }
5378 }
5384 }
5389 }
5399 }
5414 }
5420 }
5425 }
5426 });
5427 }
5434 }) {
5441 }
5447 };
5449 }
5461 };
5466 };
5478 }
5484 }
5487 }
5492 }
5499 if (pageNumber >= 1 && pageNumber <= linkService.pagesCount && pageNumber !== linkService.page && !linkService.isPageVisible(pageNumber)) {
5501 }
5507 }
5510 }
5520 }
5527 }
5531 }
5536 }
5537 }
5540 }
5544 });
5549 }
5553 }
5554 }
5561 if ((0, _pdf_find_utils.getCharacterType)(first) === (0, _pdf_find_utils.getCharacterType)(limit)) {
5563 }
5564 }
5572 if ((0, _pdf_find_utils.getCharacterType)(last) === (0, _pdf_find_utils.getCharacterType)(limit)) {
5574 }
5575 }
5578 }
5582 matchesLength = [];
5591 }
5595 }
5602 }
5606 }
5622 }
5626 }
5635 });
5636 }
5637 }
5642 this._prepareMatches(matchesWithLength, this._pageMatches[pageIndex], this._pageMatchesLength[pageIndex]);
5643 }
5650 caseSensitive,
5651 entireWord,
5652 phraseSearch
5657 }
5662 }
5668 }
5672 }
5678 }
5686 }
5687 }
5692 }
5703 });
5710 }
5719 });
5720 });
5721 }
5722 }
5727 }
5731 pageIndex: index
5732 });
5733 }
5739 });
5740 }
5764 }
5772 });
5773 }
5774 }
5780 }
5784 }
5798 }
5801 }
5804 }
5817 }
5828 }
5829 }
5832 }
5837 }
5848 }
5850 }
5862 }
5863 }
5878 }
5879 }
5887 }
5888 }
5896 }
5901 }
5906 }
5913 });
5914 }
5918 pageIdx,
5919 matchIdx
5927 }
5930 }
5934 }
5937 current,
5938 total
5939 };
5940 }
5946 });
5947 }
5952 state,
5953 previous,
5956 });
5957 }
5959 }
5964 /* 16 */
5971 }));
5983 };
5988 }
5992 }
5996 }
6000 }
6004 }
6008 }
6012 }
6016 }
6020 }
6024 }
6033 }
6040 }
6043 }
6053 }
6056 }
6059 /* 17 */
6066 }));
6079 }
6083 linkService,
6084 eventBus
6085 }) {
6096 });
6103 }, {
6105 });
6106 });
6107 }
6110 fingerprint,
6113 }) {
6117 }
6121 }
6141 hash,
6142 page,
6143 rotation
6150 }
6153 hash,
6154 page,
6155 rotation
6159 }
6167 }
6176 }
6177 }
6186 }
6191 }
6195 }
6199 explicitDest,
6200 pageNumber
6201 }) {
6204 }
6210 console.error("PDFHistory.push: " + `"${explicitDest}" is not a valid explicitDest parameter.`);
6216 }
6217 }
6223 }
6227 if (this._destination && (isDestHashesEqual(this._destination.hash, hash) || isDestArraysEqual(this._destination.dest, explicitDest))) {
6230 }
6233 }
6237 }
6241 hash,
6250 });
6251 }
6252 }
6257 }
6262 }
6266 }
6270 }
6277 });
6283 });
6284 }
6285 }
6290 }
6293 }
6298 }
6304 }
6305 }
6310 }
6316 }
6317 }
6321 }
6325 }
6329 }
6336 destination
6337 };
6348 }
6349 }
6355 }
6356 }
6361 }
6368 }
6374 }
6380 }
6384 }
6386 if (!this._destination.page && (POSITION_UPDATED_THRESHOLD <= 0 || this._numPositionUpdates <= POSITION_UPDATED_THRESHOLD)) {
6388 }
6395 }
6398 }
6401 }
6405 }
6410 }
6414 if (typeof state.fingerprint !== "string" || state.fingerprint.length !== this._fingerprint.length) {
6416 }
6422 }
6425 }
6426 }
6430 }
6434 }
6437 }
6443 }
6447 }
6453 }
6463 }
6466 hash,
6467 page,
6469 };
6470 }
6473 location
6474 }) {
6478 }
6481 hash: this._isViewerInPresentationMode ? `page=${location.pageNumber}` : location.pdfOpenParams.substring(1),
6485 };
6489 }
6491 if (POSITION_UPDATED_THRESHOLD > 0 && this._isPagesLoaded && this._destination && !this._destination.page) {
6493 }
6499 }
6503 }
6504 }
6507 state
6508 }) {
6517 hash,
6518 page,
6519 rotation
6523 hash,
6524 page,
6525 rotation
6529 }
6533 }
6542 delay: HASH_CHANGE_TIMEOUT
6545 });
6546 }
6554 }
6562 }
6566 });
6567 }
6572 }
6573 }
6578 }
6584 };
6590 }
6595 }
6602 }
6604 }
6611 }
6615 }
6618 nameddest
6623 }
6626 }
6632 }
6636 }
6641 }
6646 }
6647 }
6650 }
6653 }
6657 }
6661 }
6666 }
6667 }
6670 }
6673 /* 18 */
6680 }));
6693 }
6698 }
6703 layersCount
6704 });
6705 }
6708 groupId,
6709 input
6710 }) {
6717 });
6718 };
6726 }
6731 };
6732 }
6736 }) {
6740 }
6744 }
6748 }) {
6750 }
6755 }
6758 }
6761 optionalContentConfig,
6762 pdfDocument
6763 }) {
6766 }
6776 }
6779 queue = [{
6781 groups
6782 }];
6808 });
6814 groupId,
6815 input
6816 });
6826 layersCount++;
6827 }
6830 }
6831 }
6834 }
6839 }
6845 });
6847 optionalContentConfig,
6849 });
6850 }
6852 }
6857 /* 19 */
6864 }));
6871 eventBus,
6875 } = {}) {
6886 }
6892 }
6896 }
6900 }
6904 }
6908 }
6912 }
6916 }
6920 }
6935 console.error(`PDFLinkService._goToDestinationHelper: "${destRef}" is not ` + `a valid page reference, for dest="${rawDest}".`);
6936 });
6938 }
6942 console.error(`PDFLinkService._goToDestinationHelper: "${destRef}" is not ` + `a valid destination reference, for dest="${rawDest}".`);
6944 }
6947 console.error(`PDFLinkService._goToDestinationHelper: "${pageNumber}" is not ` + `a valid page number, for dest="${rawDest}".`);
6949 }
6954 namedDest,
6955 explicitDest,
6956 pageNumber
6957 });
6958 }
6961 pageNumber,
6964 });
6965 }
6970 }
6980 }
6983 console.error(`PDFLinkService.goToDestination: "${explicitDest}" is not ` + `a valid destination array, for dest="${dest}".`);
6985 }
6988 }
6993 }
6995 const pageNumber = typeof val === "string" && this.pdfViewer.pageLabelToPageNumber(val) || val | 0;
7000 }
7005 }
7008 pageNumber
7009 });
7010 }
7016 }
7022 }
7023 }
7026 }
7030 }
7035 }
7047 });
7048 }
7051 pageNumber = params.page | 0 || 1;
7052 }
7056 const zoomArg = zoomArgs[0];
7057 const zoomArgNumber = parseFloat(zoomArg);
7060 dest = [null, {
7062 }, zoomArgs.length > 1 ? zoomArgs[1] | 0 : null, zoomArgs.length > 2 ? zoomArgs[2] | 0 : null, zoomArgNumber ? zoomArgNumber / 100 : zoomArg];
7063 } else {
7065 dest = [null, {
7066 name: zoomArg
7067 }];
7068 } else if (zoomArg === "FitH" || zoomArg === "FitBH" || zoomArg === "FitV" || zoomArg === "FitBV") {
7069 dest = [null, {
7070 name: zoomArg
7071 }, zoomArgs.length > 1 ? zoomArgs[1] | 0 : null];
7073 if (zoomArgs.length !== 5) {
7075 } else {
7076 dest = [null, {
7077 name: zoomArg
7078 }, zoomArgs[1] | 0, zoomArgs[2] | 0, zoomArgs[3] | 0, zoomArgs[4] | 0];
7079 }
7080 } else {
7082 }
7083 }
7084 }
7086 if (dest) {
7087 this.pdfViewer.scrollPageIntoView({
7088 pageNumber: pageNumber || this.page,
7089 destArray: dest,
7090 allowNegativeOffset: true
7091 });
7092 } else if (pageNumber) {
7093 this.page = pageNumber;
7094 }
7098 source: this,
7099 mode: params.pagemode
7100 });
7101 }
7104 this.goToDestination(params.nameddest);
7105 }
7106 } else {
7107 dest = unescape(hash);
7109 try {
7110 dest = JSON.parse(dest);
7112 if (!Array.isArray(dest)) {
7113 dest = dest.toString();
7114 }
7115 } catch (ex) {}
7118 this.goToDestination(dest);
7119 return;
7120 }
7123 }
7124 }
7126 executeNamedAction(action) {
7127 switch (action) {
7129 if (this.pdfHistory) {
7130 this.pdfHistory.back();
7131 }
7133 break;
7136 if (this.pdfHistory) {
7137 this.pdfHistory.forward();
7138 }
7140 break;
7143 this.pdfViewer.nextPage();
7144 break;
7147 this.pdfViewer.previousPage();
7148 break;
7151 this.page = this.pagesCount;
7152 break;
7155 this.page = 1;
7156 break;
7158 default:
7159 break;
7160 }
7163 source: this,
7164 action
7165 });
7166 }
7168 cachePageRef(pageNum, pageRef) {
7169 if (!pageRef) {
7170 return;
7171 }
7174 this._pagesRefCache[refStr] = pageNum;
7175 }
7177 _cachedPageNumber(pageRef) {
7179 return this._pagesRefCache?.[refStr] || null;
7180 }
7182 isPageVisible(pageNumber) {
7183 return this.pdfViewer.isPageVisible(pageNumber);
7184 }
7186 isPageCached(pageNumber) {
7187 return this.pdfViewer.isPageCached(pageNumber);
7188 }
7190 }
7192 exports.PDFLinkService = PDFLinkService;
7194 function isValidExplicitDestination(dest) {
7195 if (!Array.isArray(dest)) {
7196 return false;
7197 }
7199 const destLength = dest.length;
7201 if (destLength < 2) {
7202 return false;
7203 }
7205 const page = dest[0];
7207 if (!(typeof page === "object" && Number.isInteger(page.num) && Number.isInteger(page.gen)) && !(Number.isInteger(page) && page >= 0)) {
7208 return false;
7209 }
7211 const zoom = dest[1];
7214 return false;
7215 }
7217 let allowNull = true;
7219 switch (zoom.name) {
7221 if (destLength !== 5) {
7222 return false;
7223 }
7225 break;
7229 return destLength === 2;
7235 if (destLength !== 3) {
7236 return false;
7237 }
7239 break;
7242 if (destLength !== 6) {
7243 return false;
7244 }
7246 allowNull = false;
7247 break;
7249 default:
7250 return false;
7251 }
7253 for (let i = 2; i < destLength; i++) {
7254 const param = dest[i];
7257 return false;
7258 }
7259 }
7261 return true;
7262 }
7264 class SimpleLinkService {
7265 constructor() {
7266 this.externalLinkTarget = null;
7267 this.externalLinkRel = null;
7268 this.externalLinkEnabled = true;
7269 this._ignoreDestinationZoom = false;
7270 }
7272 get pagesCount() {
7273 return 0;
7274 }
7276 get page() {
7277 return 0;
7278 }
7280 set page(value) {}
7282 get rotation() {
7283 return 0;
7284 }
7286 set rotation(value) {}
7288 async goToDestination(dest) {}
7290 goToPage(val) {}
7292 getDestinationHash(dest) {
7294 }
7296 getAnchorUrl(hash) {
7298 }
7300 setHash(hash) {}
7302 executeNamedAction(action) {}
7304 cachePageRef(pageNum, pageRef) {}
7306 isPageVisible(pageNumber) {
7307 return true;
7308 }
7310 isPageCached(pageNumber) {
7311 return true;
7312 }
7314 }
7316 exports.SimpleLinkService = SimpleLinkService;
7318 /***/ }),
7319 /* 20 */
7320 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
7325 value: true
7326 }));
7327 exports.PDFOutlineViewer = void 0;
7329 var _pdfjsLib = __webpack_require__(5);
7331 var _base_tree_viewer = __webpack_require__(12);
7333 var _ui_utils = __webpack_require__(4);
7335 class PDFOutlineViewer extends _base_tree_viewer.BaseTreeViewer {
7336 constructor(options) {
7337 super(options);
7338 this.linkService = options.linkService;
7345 this._currentPageNumber = evt.pageNumber;
7346 });
7349 this._isPagesLoaded = !!evt.pagesCount;
7351 if (this._currentOutlineItemCapability && !this._currentOutlineItemCapability.settled) {
7352 this._currentOutlineItemCapability.resolve(this._isPagesLoaded);
7353 }
7354 });
7357 this._sidebarView = evt.view;
7358 });
7359 }
7361 reset() {
7362 super.reset();
7363 this._outline = null;
7364 this._pageNumberToDestHashCapability = null;
7365 this._currentPageNumber = 1;
7366 this._isPagesLoaded = false;
7368 if (this._currentOutlineItemCapability && !this._currentOutlineItemCapability.settled) {
7369 this._currentOutlineItemCapability.resolve(false);
7370 }
7372 this._currentOutlineItemCapability = null;
7373 }
7375 _dispatchEvent(outlineCount) {
7376 this._currentOutlineItemCapability = (0, _pdfjsLib.createPromiseCapability)();
7378 if (outlineCount === 0 || this._pdfDocument?.loadingParams.disableAutoFetch) {
7379 this._currentOutlineItemCapability.resolve(false);
7380 } else if (this._isPagesLoaded) {
7381 this._currentOutlineItemCapability.resolve(true);
7382 }
7385 source: this,
7386 outlineCount,
7387 currentOutlineItemPromise: this._currentOutlineItemCapability.promise
7388 });
7389 }
7391 _bindLink(element, {
7392 url,
7393 newWindow,
7394 dest
7395 }) {
7396 const {
7397 linkService
7398 } = this;
7400 if (url) {
7401 (0, _pdfjsLib.addLinkAttributes)(element, {
7402 url,
7403 target: newWindow ? _pdfjsLib.LinkTarget.BLANK : linkService.externalLinkTarget,
7404 rel: linkService.externalLinkRel,
7405 enabled: linkService.externalLinkEnabled
7406 });
7407 return;
7408 }
7410 element.href = linkService.getDestinationHash(dest);
7412 element.onclick = evt => {
7413 this._updateCurrentTreeItem(evt.target.parentNode);
7415 if (dest) {
7416 linkService.goToDestination(dest);
7417 }
7419 return false;
7420 };
7421 }
7423 _setStyles(element, {
7424 bold,
7425 italic
7426 }) {
7427 if (bold) {
7429 }
7431 if (italic) {
7433 }
7434 }
7436 _addToggleButton(div, {
7437 count,
7438 items
7439 }) {
7440 let hidden = false;
7442 if (count < 0) {
7443 let totalCount = items.length;
7445 if (totalCount > 0) {
7446 const queue = [...items];
7448 while (queue.length > 0) {
7449 const {
7450 count: nestedCount,
7451 items: nestedItems
7452 } = queue.shift();
7454 if (nestedCount > 0 && nestedItems.length > 0) {
7455 totalCount += nestedItems.length;
7456 queue.push(...nestedItems);
7457 }
7458 }
7459 }
7461 if (Math.abs(count) === totalCount) {
7462 hidden = true;
7463 }
7464 }
7466 super._addToggleButton(div, hidden);
7467 }
7469 _toggleAllTreeItems() {
7470 if (!this._outline) {
7471 return;
7472 }
7474 super._toggleAllTreeItems();
7475 }
7477 render({
7478 outline,
7479 pdfDocument
7480 }) {
7481 if (this._outline) {
7482 this.reset();
7483 }
7485 this._outline = outline || null;
7486 this._pdfDocument = pdfDocument || null;
7488 if (!outline) {
7489 this._dispatchEvent(0);
7491 return;
7492 }
7494 const fragment = document.createDocumentFragment();
7495 const queue = [{
7496 parent: fragment,
7497 items: outline
7498 }];
7499 let outlineCount = 0,
7500 hasAnyNesting = false;
7502 while (queue.length > 0) {
7503 const levelData = queue.shift();
7505 for (const item of levelData.items) {
7510 this._bindLink(element, item);
7512 this._setStyles(element, item);
7514 element.textContent = this._normalizeTextContent(item.title);
7515 div.appendChild(element);
7517 if (item.items.length > 0) {
7518 hasAnyNesting = true;
7520 this._addToggleButton(div, item);
7524 div.appendChild(itemsDiv);
7525 queue.push({
7526 parent: itemsDiv,
7527 items: item.items
7528 });
7529 }
7531 levelData.parent.appendChild(div);
7532 outlineCount++;
7533 }
7534 }
7536 this._finishRendering(fragment, outlineCount, hasAnyNesting);
7537 }
7539 async _currentOutlineItem() {
7540 if (!this._isPagesLoaded) {
7542 }
7544 if (!this._outline || !this._pdfDocument) {
7545 return;
7546 }
7548 const pageNumberToDestHash = await this._getPageNumberToDestHash(this._pdfDocument);
7550 if (!pageNumberToDestHash) {
7551 return;
7552 }
7554 this._updateCurrentTreeItem(null);
7556 if (this._sidebarView !== _ui_utils.SidebarView.OUTLINE) {
7557 return;
7558 }
7560 for (let i = this._currentPageNumber; i > 0; i--) {
7561 const destHash = pageNumberToDestHash.get(i);
7563 if (!destHash) {
7564 continue;
7565 }
7569 if (!linkElement) {
7570 continue;
7571 }
7573 this._scrollToCurrentTreeItem(linkElement.parentNode);
7575 break;
7576 }
7577 }
7579 async _getPageNumberToDestHash(pdfDocument) {
7580 if (this._pageNumberToDestHashCapability) {
7581 return this._pageNumberToDestHashCapability.promise;
7582 }
7584 this._pageNumberToDestHashCapability = (0, _pdfjsLib.createPromiseCapability)();
7585 const pageNumberToDestHash = new Map(),
7586 pageNumberNesting = new Map();
7587 const queue = [{
7588 nesting: 0,
7589 items: this._outline
7590 }];
7592 while (queue.length > 0) {
7593 const levelData = queue.shift(),
7594 currentNesting = levelData.nesting;
7596 for (const {
7597 dest,
7598 items
7599 } of levelData.items) {
7600 let explicitDest, pageNumber;
7603 explicitDest = await pdfDocument.getDestination(dest);
7605 if (pdfDocument !== this._pdfDocument) {
7606 return null;
7607 }
7608 } else {
7609 explicitDest = dest;
7610 }
7612 if (Array.isArray(explicitDest)) {
7613 const [destRef] = explicitDest;
7616 pageNumber = this.linkService._cachedPageNumber(destRef);
7618 if (!pageNumber) {
7619 try {
7620 pageNumber = (await pdfDocument.getPageIndex(destRef)) + 1;
7622 if (pdfDocument !== this._pdfDocument) {
7623 return null;
7624 }
7626 this.linkService.cachePageRef(pageNumber, destRef);
7627 } catch (ex) {}
7628 }
7629 } else if (Number.isInteger(destRef)) {
7630 pageNumber = destRef + 1;
7631 }
7633 if (Number.isInteger(pageNumber) && (!pageNumberToDestHash.has(pageNumber) || currentNesting > pageNumberNesting.get(pageNumber))) {
7634 const destHash = this.linkService.getDestinationHash(dest);
7635 pageNumberToDestHash.set(pageNumber, destHash);
7636 pageNumberNesting.set(pageNumber, currentNesting);
7637 }
7638 }
7640 if (items.length > 0) {
7641 queue.push({
7642 nesting: currentNesting + 1,
7643 items
7644 });
7645 }
7646 }
7647 }
7649 this._pageNumberToDestHashCapability.resolve(pageNumberToDestHash.size > 0 ? pageNumberToDestHash : null);
7651 return this._pageNumberToDestHashCapability.promise;
7652 }
7654 }
7656 exports.PDFOutlineViewer = PDFOutlineViewer;
7658 /***/ }),
7659 /* 21 */
7660 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
7665 value: true
7666 }));
7667 exports.PDFPresentationMode = void 0;
7669 var _ui_utils = __webpack_require__(4);
7671 const DELAY_BEFORE_RESETTING_SWITCH_IN_PROGRESS = 1500;
7672 const DELAY_BEFORE_HIDING_CONTROLS = 3000;
7675 const MOUSE_SCROLL_COOLDOWN_TIME = 50;
7676 const PAGE_SWITCH_THRESHOLD = 0.1;
7677 const SWIPE_MIN_DISTANCE_THRESHOLD = 50;
7678 const SWIPE_ANGLE_THRESHOLD = Math.PI / 6;
7680 class PDFPresentationMode {
7681 constructor({
7682 container,
7683 pdfViewer,
7684 eventBus
7685 }) {
7686 this.container = container;
7687 this.pdfViewer = pdfViewer;
7688 this.eventBus = eventBus;
7689 this.active = false;
7690 this.args = null;
7691 this.contextMenuOpen = false;
7692 this.mouseScrollTimeStamp = 0;
7693 this.mouseScrollDelta = 0;
7694 this.touchSwipeState = null;
7695 }
7697 request() {
7698 if (this.switchInProgress || this.active || !this.pdfViewer.pagesCount) {
7699 return false;
7700 }
7702 this._addFullscreenChangeListeners();
7704 this._setSwitchInProgress();
7706 this._notifyStateChange();
7708 if (this.container.requestFullscreen) {
7709 this.container.requestFullscreen();
7710 } else if (this.container.mozRequestFullScreen) {
7711 this.container.mozRequestFullScreen();
7712 } else if (this.container.webkitRequestFullscreen) {
7713 this.container.webkitRequestFullscreen(Element.ALLOW_KEYBOARD_INPUT);
7714 } else {
7715 return false;
7716 }
7718 this.args = {
7719 page: this.pdfViewer.currentPageNumber,
7720 previousScale: this.pdfViewer.currentScaleValue
7721 };
7722 return true;
7723 }
7725 _mouseWheel(evt) {
7726 if (!this.active) {
7727 return;
7728 }
7730 evt.preventDefault();
7731 const delta = (0, _ui_utils.normalizeWheelEventDelta)(evt);
7732 const currentTime = Date.now();
7733 const storedTime = this.mouseScrollTimeStamp;
7735 if (currentTime > storedTime && currentTime - storedTime < MOUSE_SCROLL_COOLDOWN_TIME) {
7736 return;
7737 }
7739 if (this.mouseScrollDelta > 0 && delta < 0 || this.mouseScrollDelta < 0 && delta > 0) {
7740 this._resetMouseScrollState();
7741 }
7743 this.mouseScrollDelta += delta;
7745 if (Math.abs(this.mouseScrollDelta) >= PAGE_SWITCH_THRESHOLD) {
7746 const totalDelta = this.mouseScrollDelta;
7748 this._resetMouseScrollState();
7750 const success = totalDelta > 0 ? this.pdfViewer.previousPage() : this.pdfViewer.nextPage();
7752 if (success) {
7753 this.mouseScrollTimeStamp = currentTime;
7754 }
7755 }
7756 }
7758 get isFullscreen() {
7759 return !!(document.fullscreenElement || document.mozFullScreen || document.webkitIsFullScreen);
7760 }
7762 _notifyStateChange() {
7763 let state = _ui_utils.PresentationModeState.NORMAL;
7765 if (this.switchInProgress) {
7766 state = _ui_utils.PresentationModeState.CHANGING;
7767 } else if (this.active) {
7768 state = _ui_utils.PresentationModeState.FULLSCREEN;
7769 }
7772 source: this,
7773 state
7774 });
7775 }
7777 _setSwitchInProgress() {
7778 if (this.switchInProgress) {
7779 clearTimeout(this.switchInProgress);
7780 }
7782 this.switchInProgress = setTimeout(() => {
7783 this._removeFullscreenChangeListeners();
7785 delete this.switchInProgress;
7787 this._notifyStateChange();
7788 }, DELAY_BEFORE_RESETTING_SWITCH_IN_PROGRESS);
7789 }
7791 _resetSwitchInProgress() {
7792 if (this.switchInProgress) {
7793 clearTimeout(this.switchInProgress);
7794 delete this.switchInProgress;
7795 }
7796 }
7798 _enter() {
7799 this.active = true;
7801 this._resetSwitchInProgress();
7803 this._notifyStateChange();
7805 this.container.classList.add(ACTIVE_SELECTOR);
7806 setTimeout(() => {
7807 this.pdfViewer.currentPageNumber = this.args.page;
7809 }, 0);
7811 this._addWindowListeners();
7813 this._showControls();
7815 this.contextMenuOpen = false;
7816 window.getSelection().removeAllRanges();
7817 }
7819 _exit() {
7820 const page = this.pdfViewer.currentPageNumber;
7821 this.container.classList.remove(ACTIVE_SELECTOR);
7822 setTimeout(() => {
7823 this.active = false;
7825 this._removeFullscreenChangeListeners();
7827 this._notifyStateChange();
7829 this.pdfViewer.currentScaleValue = this.args.previousScale;
7830 this.pdfViewer.currentPageNumber = page;
7831 this.args = null;
7832 }, 0);
7834 this._removeWindowListeners();
7836 this._hideControls();
7838 this._resetMouseScrollState();
7840 this.contextMenuOpen = false;
7841 }
7843 _mouseDown(evt) {
7844 if (this.contextMenuOpen) {
7845 this.contextMenuOpen = false;
7846 evt.preventDefault();
7847 return;
7848 }
7850 if (evt.button === 0) {
7853 if (!isInternalLink) {
7854 evt.preventDefault();
7856 if (evt.shiftKey) {
7857 this.pdfViewer.previousPage();
7858 } else {
7859 this.pdfViewer.nextPage();
7860 }
7861 }
7862 }
7863 }
7865 _contextMenu() {
7866 this.contextMenuOpen = true;
7867 }
7869 _showControls() {
7870 if (this.controlsTimeout) {
7871 clearTimeout(this.controlsTimeout);
7872 } else {
7873 this.container.classList.add(CONTROLS_SELECTOR);
7874 }
7876 this.controlsTimeout = setTimeout(() => {
7877 this.container.classList.remove(CONTROLS_SELECTOR);
7878 delete this.controlsTimeout;
7879 }, DELAY_BEFORE_HIDING_CONTROLS);
7880 }
7882 _hideControls() {
7883 if (!this.controlsTimeout) {
7884 return;
7885 }
7887 clearTimeout(this.controlsTimeout);
7888 this.container.classList.remove(CONTROLS_SELECTOR);
7889 delete this.controlsTimeout;
7890 }
7892 _resetMouseScrollState() {
7893 this.mouseScrollTimeStamp = 0;
7894 this.mouseScrollDelta = 0;
7895 }
7897 _touchSwipe(evt) {
7898 if (!this.active) {
7899 return;
7900 }
7902 if (evt.touches.length > 1) {
7903 this.touchSwipeState = null;
7904 return;
7905 }
7907 switch (evt.type) {
7909 this.touchSwipeState = {
7910 startX: evt.touches[0].pageX,
7911 startY: evt.touches[0].pageY,
7912 endX: evt.touches[0].pageX,
7913 endY: evt.touches[0].pageY
7914 };
7915 break;
7918 if (this.touchSwipeState === null) {
7919 return;
7920 }
7922 this.touchSwipeState.endX = evt.touches[0].pageX;
7923 this.touchSwipeState.endY = evt.touches[0].pageY;
7924 evt.preventDefault();
7925 break;
7928 if (this.touchSwipeState === null) {
7929 return;
7930 }
7932 let delta = 0;
7933 const dx = this.touchSwipeState.endX - this.touchSwipeState.startX;
7934 const dy = this.touchSwipeState.endY - this.touchSwipeState.startY;
7935 const absAngle = Math.abs(Math.atan2(dy, dx));
7937 if (Math.abs(dx) > SWIPE_MIN_DISTANCE_THRESHOLD && (absAngle <= SWIPE_ANGLE_THRESHOLD || absAngle >= Math.PI - SWIPE_ANGLE_THRESHOLD)) {
7938 delta = dx;
7939 } else if (Math.abs(dy) > SWIPE_MIN_DISTANCE_THRESHOLD && Math.abs(absAngle - Math.PI / 2) <= SWIPE_ANGLE_THRESHOLD) {
7940 delta = dy;
7941 }
7943 if (delta > 0) {
7944 this.pdfViewer.previousPage();
7945 } else if (delta < 0) {
7946 this.pdfViewer.nextPage();
7947 }
7949 break;
7950 }
7951 }
7953 _addWindowListeners() {
7954 this.showControlsBind = this._showControls.bind(this);
7955 this.mouseDownBind = this._mouseDown.bind(this);
7956 this.mouseWheelBind = this._mouseWheel.bind(this);
7957 this.resetMouseScrollStateBind = this._resetMouseScrollState.bind(this);
7958 this.contextMenuBind = this._contextMenu.bind(this);
7959 this.touchSwipeBind = this._touchSwipe.bind(this);
7963 passive: false
7964 });
7970 }
7972 _removeWindowListeners() {
7976 passive: false
7977 });
7983 delete this.showControlsBind;
7984 delete this.mouseDownBind;
7985 delete this.mouseWheelBind;
7986 delete this.resetMouseScrollStateBind;
7987 delete this.contextMenuBind;
7988 delete this.touchSwipeBind;
7989 }
7991 _fullscreenChange() {
7992 if (this.isFullscreen) {
7993 this._enter();
7994 } else {
7995 this._exit();
7996 }
7997 }
7999 _addFullscreenChangeListeners() {
8000 this.fullscreenChangeBind = this._fullscreenChange.bind(this);
8004 }
8006 _removeFullscreenChangeListeners() {
8010 delete this.fullscreenChangeBind;
8011 }
8013 }
8015 exports.PDFPresentationMode = PDFPresentationMode;
8017 /***/ }),
8018 /* 22 */
8019 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
8024 value: true
8025 }));
8026 exports.PDFScriptingManager = void 0;
8028 var _pdfjsLib = __webpack_require__(5);
8030 var _ui_utils = __webpack_require__(4);
8032 var _pdf_rendering_queue = __webpack_require__(8);
8034 class PDFScriptingManager {
8035 constructor({
8036 eventBus,
8037 sandboxBundleSrc = null,
8038 scriptingFactory = null,
8039 docPropertiesLookup = null
8040 }) {
8041 this._pdfDocument = null;
8042 this._pdfViewer = null;
8043 this._closeCapability = null;
8044 this._destroyCapability = null;
8045 this._scripting = null;
8046 this._mouseState = Object.create(null);
8047 this._ready = false;
8048 this._eventBus = eventBus;
8049 this._sandboxBundleSrc = sandboxBundleSrc;
8050 this._scriptingFactory = scriptingFactory;
8051 this._docPropertiesLookup = docPropertiesLookup;
8052 }
8054 setViewer(pdfViewer) {
8055 this._pdfViewer = pdfViewer;
8056 }
8058 async setDocument(pdfDocument) {
8059 if (this._pdfDocument) {
8060 await this._destroyScripting();
8061 }
8063 this._pdfDocument = pdfDocument;
8065 if (!pdfDocument) {
8066 return;
8067 }
8069 const [objects, calculationOrder, docActions] = await Promise.all([pdfDocument.getFieldObjects(), pdfDocument.getCalculationOrderIds(), pdfDocument.getJSActions()]);
8071 if (!objects && !docActions) {
8072 await this._destroyScripting();
8073 return;
8074 }
8076 if (pdfDocument !== this._pdfDocument) {
8077 return;
8078 }
8080 try {
8081 this._scripting = this._createScripting();
8082 } catch (error) {
8084 await this._destroyScripting();
8085 return;
8086 }
8089 if (event?.source !== window) {
8090 return;
8091 }
8093 this._updateFromSandbox(event.detail);
8094 });
8097 this._scripting?.dispatchEventInSandbox(event.detail);
8098 });
8101 pageNumber,
8102 previous
8103 }) => {
8104 if (pageNumber === previous) {
8105 return;
8106 }
8108 this._dispatchPageClose(previous);
8110 this._dispatchPageOpen(pageNumber);
8111 });
8114 pageNumber
8115 }) => {
8116 if (!this._pageOpenPending.has(pageNumber)) {
8117 return;
8118 }
8120 if (pageNumber !== this._pdfViewer.currentPageNumber) {
8121 return;
8122 }
8124 this._dispatchPageOpen(pageNumber);
8125 });
8128 await this._dispatchPageClose(this._pdfViewer.currentPageNumber);
8129 await this._scripting?.dispatchEventInSandbox({
8132 });
8133 this._closeCapability?.resolve();
8134 });
8137 this._mouseState.isDown = true;
8138 });
8141 this._mouseState.isDown = false;
8142 });
8144 for (const [name, listener] of this._internalEvents) {
8145 this._eventBus._on(name, listener);
8146 }
8148 for (const [name, listener] of this._domEvents) {
8149 window.addEventListener(name, listener);
8150 }
8152 try {
8153 const docProperties = await this._getDocProperties();
8155 if (pdfDocument !== this._pdfDocument) {
8156 return;
8157 }
8159 await this._scripting.createSandbox({
8160 objects,
8161 calculationOrder,
8162 appInfo: {
8163 platform: navigator.platform,
8164 language: navigator.language
8165 },
8166 docInfo: { ...docProperties,
8167 actions: docActions
8168 }
8169 });
8172 source: this
8173 });
8174 } catch (error) {
8176 await this._destroyScripting();
8177 return;
8178 }
8180 await this._scripting?.dispatchEventInSandbox({
8183 });
8184 await this._dispatchPageOpen(this._pdfViewer.currentPageNumber, true);
8185 Promise.resolve().then(() => {
8186 if (pdfDocument === this._pdfDocument) {
8187 this._ready = true;
8188 }
8189 });
8190 }
8192 async dispatchWillSave(detail) {
8193 return this._scripting?.dispatchEventInSandbox({
8196 });
8197 }
8199 async dispatchDidSave(detail) {
8200 return this._scripting?.dispatchEventInSandbox({
8203 });
8204 }
8206 async dispatchWillPrint(detail) {
8207 return this._scripting?.dispatchEventInSandbox({
8210 });
8211 }
8213 async dispatchDidPrint(detail) {
8214 return this._scripting?.dispatchEventInSandbox({
8217 });
8218 }
8220 get mouseState() {
8221 return this._mouseState;
8222 }
8224 get destroyPromise() {
8225 return this._destroyCapability?.promise || null;
8226 }
8228 get ready() {
8229 return this._ready;
8230 }
8232 get _internalEvents() {
8234 }
8236 get _domEvents() {
8238 }
8240 get _pageOpenPending() {
8242 }
8244 get _visitedPages() {
8246 }
8248 async _updateFromSandbox(detail) {
8249 const isInPresentationMode = this._pdfViewer.isInPresentationMode || this._pdfViewer.isChangingPresentationMode;
8250 const {
8251 id,
8252 siblings,
8253 command,
8254 value
8255 } = detail;
8257 if (!id) {
8258 switch (command) {
8260 console.clear();
8261 break;
8264 console.error(value);
8265 break;
8268 this._pdfViewer.spreadMode = (0, _ui_utils.apiPageLayoutToSpreadMode)(value);
8269 break;
8272 this._pdfViewer.currentPageNumber = value + 1;
8273 break;
8276 await this._pdfViewer.pagesPromise;
8279 source: this
8280 });
8282 break;
8285 console.log(value);
8286 break;
8289 if (isInPresentationMode) {
8290 return;
8291 }
8293 this._pdfViewer.currentScaleValue = value;
8294 break;
8295 }
8297 return;
8298 }
8300 if (isInPresentationMode) {
8301 if (detail.focus) {
8302 return;
8303 }
8304 }
8306 delete detail.id;
8307 delete detail.siblings;
8308 const ids = siblings ? [id, ...siblings] : [id];
8310 for (const elementId of ids) {
8311 const element = document.getElementById(elementId);
8313 if (element) {
8315 detail
8316 }));
8317 } else {
8318 this._pdfDocument?.annotationStorage.setValue(elementId, detail);
8319 }
8320 }
8321 }
8323 async _dispatchPageOpen(pageNumber, initialize = false) {
8324 const pdfDocument = this._pdfDocument,
8325 visitedPages = this._visitedPages;
8327 if (initialize) {
8328 this._closeCapability = (0, _pdfjsLib.createPromiseCapability)();
8329 }
8331 if (!this._closeCapability) {
8332 return;
8333 }
8335 const pageView = this._pdfViewer.getPageView(pageNumber - 1);
8337 if (pageView?.renderingState !== _pdf_rendering_queue.RenderingStates.FINISHED) {
8338 this._pageOpenPending.add(pageNumber);
8340 return;
8341 }
8343 this._pageOpenPending.delete(pageNumber);
8345 const actionsPromise = (async () => {
8346 const actions = await (!visitedPages.has(pageNumber) ? pageView.pdfPage?.getJSActions() : null);
8348 if (pdfDocument !== this._pdfDocument) {
8349 return;
8350 }
8352 await this._scripting?.dispatchEventInSandbox({
8355 pageNumber,
8356 actions
8357 });
8358 })();
8360 visitedPages.set(pageNumber, actionsPromise);
8361 }
8363 async _dispatchPageClose(pageNumber) {
8364 const pdfDocument = this._pdfDocument,
8365 visitedPages = this._visitedPages;
8367 if (!this._closeCapability) {
8368 return;
8369 }
8371 if (this._pageOpenPending.has(pageNumber)) {
8372 return;
8373 }
8375 const actionsPromise = visitedPages.get(pageNumber);
8377 if (!actionsPromise) {
8378 return;
8379 }
8381 visitedPages.set(pageNumber, null);
8382 await actionsPromise;
8384 if (pdfDocument !== this._pdfDocument) {
8385 return;
8386 }
8388 await this._scripting?.dispatchEventInSandbox({
8391 pageNumber
8392 });
8393 }
8395 async _getDocProperties() {
8396 if (this._docPropertiesLookup) {
8397 return this._docPropertiesLookup(this._pdfDocument);
8398 }
8401 }
8403 _createScripting() {
8404 this._destroyCapability = (0, _pdfjsLib.createPromiseCapability)();
8406 if (this._scripting) {
8408 }
8410 if (this._scriptingFactory) {
8411 return this._scriptingFactory.createScripting({
8412 sandboxBundleSrc: this._sandboxBundleSrc
8413 });
8414 }
8417 }
8419 async _destroyScripting() {
8420 if (!this._scripting) {
8421 this._pdfDocument = null;
8422 this._destroyCapability?.resolve();
8423 return;
8424 }
8426 if (this._closeCapability) {
8427 await Promise.race([this._closeCapability.promise, new Promise(resolve => {
8428 setTimeout(resolve, 1000);
8429 })]).catch(reason => {});
8430 this._closeCapability = null;
8431 }
8433 this._pdfDocument = null;
8435 try {
8436 await this._scripting.destroySandbox();
8437 } catch (ex) {}
8439 for (const [name, listener] of this._internalEvents) {
8440 this._eventBus._off(name, listener);
8441 }
8443 this._internalEvents.clear();
8445 for (const [name, listener] of this._domEvents) {
8446 window.removeEventListener(name, listener);
8447 }
8449 this._domEvents.clear();
8451 this._pageOpenPending.clear();
8453 this._visitedPages.clear();
8455 this._scripting = null;
8456 delete this._mouseState.isDown;
8457 this._ready = false;
8458 this._destroyCapability?.resolve();
8459 }
8461 }
8463 exports.PDFScriptingManager = PDFScriptingManager;
8465 /***/ }),
8466 /* 23 */
8467 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
8472 value: true
8473 }));
8474 exports.PDFSidebar = void 0;
8476 var _ui_utils = __webpack_require__(4);
8478 var _pdf_rendering_queue = __webpack_require__(8);
8482 class PDFSidebar {
8483 constructor({
8484 elements,
8485 pdfViewer,
8486 pdfThumbnailViewer,
8487 eventBus,
8488 l10n
8489 }) {
8490 this.isOpen = false;
8491 this.active = _ui_utils.SidebarView.THUMBS;
8492 this.isInitialViewSet = false;
8493 this.onToggled = null;
8494 this.pdfViewer = pdfViewer;
8495 this.pdfThumbnailViewer = pdfThumbnailViewer;
8496 this.outerContainer = elements.outerContainer;
8497 this.viewerContainer = elements.viewerContainer;
8498 this.toggleButton = elements.toggleButton;
8499 this.thumbnailButton = elements.thumbnailButton;
8500 this.outlineButton = elements.outlineButton;
8501 this.attachmentsButton = elements.attachmentsButton;
8502 this.layersButton = elements.layersButton;
8503 this.thumbnailView = elements.thumbnailView;
8504 this.outlineView = elements.outlineView;
8505 this.attachmentsView = elements.attachmentsView;
8506 this.layersView = elements.layersView;
8507 this._outlineOptionsContainer = elements.outlineOptionsContainer;
8508 this._currentOutlineItemButton = elements.currentOutlineItemButton;
8509 this.eventBus = eventBus;
8510 this.l10n = l10n;
8512 this._addEventListeners();
8513 }
8515 reset() {
8516 this.isInitialViewSet = false;
8518 this._hideUINotification(true);
8520 this.switchView(_ui_utils.SidebarView.THUMBS);
8521 this.outlineButton.disabled = false;
8522 this.attachmentsButton.disabled = false;
8523 this.layersButton.disabled = false;
8524 this._currentOutlineItemButton.disabled = true;
8525 }
8527 get visibleView() {
8528 return this.isOpen ? this.active : _ui_utils.SidebarView.NONE;
8529 }
8531 get isThumbnailViewVisible() {
8532 return this.isOpen && this.active === _ui_utils.SidebarView.THUMBS;
8533 }
8535 get isOutlineViewVisible() {
8536 return this.isOpen && this.active === _ui_utils.SidebarView.OUTLINE;
8537 }
8539 get isAttachmentsViewVisible() {
8540 return this.isOpen && this.active === _ui_utils.SidebarView.ATTACHMENTS;
8541 }
8543 get isLayersViewVisible() {
8544 return this.isOpen && this.active === _ui_utils.SidebarView.LAYERS;
8545 }
8547 setInitialView(view = _ui_utils.SidebarView.NONE) {
8548 if (this.isInitialViewSet) {
8549 return;
8550 }
8552 this.isInitialViewSet = true;
8554 if (view === _ui_utils.SidebarView.NONE || view === _ui_utils.SidebarView.UNKNOWN) {
8555 this._dispatchEvent();
8557 return;
8558 }
8560 if (!this._switchView(view, true)) {
8561 this._dispatchEvent();
8562 }
8563 }
8565 switchView(view, forceOpen = false) {
8566 this._switchView(view, forceOpen);
8567 }
8569 _switchView(view, forceOpen = false) {
8570 const isViewChanged = view !== this.active;
8571 let shouldForceRendering = false;
8573 switch (view) {
8574 case _ui_utils.SidebarView.NONE:
8575 if (this.isOpen) {
8576 this.close();
8577 return true;
8578 }
8580 return false;
8582 case _ui_utils.SidebarView.THUMBS:
8583 if (this.isOpen && isViewChanged) {
8584 shouldForceRendering = true;
8585 }
8587 break;
8589 case _ui_utils.SidebarView.OUTLINE:
8590 if (this.outlineButton.disabled) {
8591 return false;
8592 }
8594 break;
8596 case _ui_utils.SidebarView.ATTACHMENTS:
8597 if (this.attachmentsButton.disabled) {
8598 return false;
8599 }
8601 break;
8603 case _ui_utils.SidebarView.LAYERS:
8604 if (this.layersButton.disabled) {
8605 return false;
8606 }
8608 break;
8610 default:
8612 return false;
8613 }
8615 this.active = view;
8618 this.attachmentsButton.classList.toggle("toggled", view === _ui_utils.SidebarView.ATTACHMENTS);
8625 this._outlineOptionsContainer.classList.toggle("hidden", view !== _ui_utils.SidebarView.OUTLINE);
8627 if (forceOpen && !this.isOpen) {
8628 this.open();
8629 return true;
8630 }
8632 if (shouldForceRendering) {
8633 this._updateThumbnailViewer();
8635 this._forceRendering();
8636 }
8638 if (isViewChanged) {
8639 this._dispatchEvent();
8640 }
8642 return isViewChanged;
8643 }
8645 open() {
8646 if (this.isOpen) {
8647 return;
8648 }
8650 this.isOpen = true;
8655 if (this.active === _ui_utils.SidebarView.THUMBS) {
8656 this._updateThumbnailViewer();
8657 }
8659 this._forceRendering();
8661 this._dispatchEvent();
8663 this._hideUINotification();
8664 }
8666 close() {
8667 if (!this.isOpen) {
8668 return;
8669 }
8671 this.isOpen = false;
8677 this._forceRendering();
8679 this._dispatchEvent();
8680 }
8682 toggle() {
8683 if (this.isOpen) {
8684 this.close();
8685 } else {
8686 this.open();
8687 }
8688 }
8690 _dispatchEvent() {
8692 source: this,
8693 view: this.visibleView
8694 });
8695 }
8697 _forceRendering() {
8698 if (this.onToggled) {
8699 this.onToggled();
8700 } else {
8701 this.pdfViewer.forceRendering();
8702 this.pdfThumbnailViewer.forceRendering();
8703 }
8704 }
8706 _updateThumbnailViewer() {
8707 const {
8708 pdfViewer,
8709 pdfThumbnailViewer
8710 } = this;
8711 const pagesCount = pdfViewer.pagesCount;
8713 for (let pageIndex = 0; pageIndex < pagesCount; pageIndex++) {
8714 const pageView = pdfViewer.getPageView(pageIndex);
8716 if (pageView?.renderingState === _pdf_rendering_queue.RenderingStates.FINISHED) {
8717 const thumbnailView = pdfThumbnailViewer.getThumbnail(pageIndex);
8718 thumbnailView.setImage(pageView);
8719 }
8720 }
8722 pdfThumbnailViewer.scrollThumbnailIntoView(pdfViewer.currentPageNumber);
8723 }
8725 _showUINotification() {
8727 this.toggleButton.title = msg;
8728 });
8730 if (!this.isOpen) {
8731 this.toggleButton.classList.add(UI_NOTIFICATION_CLASS);
8732 }
8733 }
8735 _hideUINotification(reset = false) {
8736 if (this.isOpen || reset) {
8737 this.toggleButton.classList.remove(UI_NOTIFICATION_CLASS);
8738 }
8740 if (reset) {
8742 this.toggleButton.title = msg;
8743 });
8744 }
8745 }
8747 _addEventListeners() {
8749 if (evt.target === this.viewerContainer) {
8751 }
8752 });
8754 this.toggle();
8755 });
8757 this.switchView(_ui_utils.SidebarView.THUMBS);
8758 });
8760 this.switchView(_ui_utils.SidebarView.OUTLINE);
8761 });
8764 source: this
8765 });
8766 });
8768 this.switchView(_ui_utils.SidebarView.ATTACHMENTS);
8769 });
8771 this.switchView(_ui_utils.SidebarView.LAYERS);
8772 });
8775 source: this
8776 });
8777 });
8781 source: this
8782 });
8783 });
8785 const onTreeLoaded = (count, button, view) => {
8786 button.disabled = !count;
8788 if (count) {
8789 this._showUINotification();
8790 } else if (this.active === view) {
8791 this.switchView(_ui_utils.SidebarView.THUMBS);
8792 }
8793 };
8796 onTreeLoaded(evt.outlineCount, this.outlineButton, _ui_utils.SidebarView.OUTLINE);
8797 evt.currentOutlineItemPromise.then(enabled => {
8798 if (!this.isInitialViewSet) {
8799 return;
8800 }
8802 this._currentOutlineItemButton.disabled = !enabled;
8803 });
8804 });
8807 onTreeLoaded(evt.attachmentsCount, this.attachmentsButton, _ui_utils.SidebarView.ATTACHMENTS);
8808 });
8811 onTreeLoaded(evt.layersCount, this.layersButton, _ui_utils.SidebarView.LAYERS);
8812 });
8815 if (evt.state === _ui_utils.PresentationModeState.NORMAL && this.isThumbnailViewVisible) {
8816 this._updateThumbnailViewer();
8817 }
8818 });
8819 }
8821 }
8823 exports.PDFSidebar = PDFSidebar;
8825 /***/ }),
8826 /* 24 */
8827 /***/ ((__unused_webpack_module, exports) => {
8832 value: true
8833 }));
8834 exports.PDFSidebarResizer = void 0;
8836 const SIDEBAR_MIN_WIDTH = 200;
8839 class PDFSidebarResizer {
8840 constructor(options, eventBus, l10n) {
8841 this.isRTL = false;
8842 this.sidebarOpen = false;
8843 this.doc = document.documentElement;
8844 this._width = null;
8845 this._outerContainerWidth = null;
8846 this._boundEvents = Object.create(null);
8847 this.outerContainer = options.outerContainer;
8848 this.resizer = options.resizer;
8849 this.eventBus = eventBus;
8850 l10n.getDirection().then(dir => {
8852 });
8854 this._addEventListeners();
8855 }
8857 get outerContainerWidth() {
8858 return this._outerContainerWidth || (this._outerContainerWidth = this.outerContainer.clientWidth);
8859 }
8861 _updateWidth(width = 0) {
8862 const maxWidth = Math.floor(this.outerContainerWidth / 2);
8864 if (width > maxWidth) {
8865 width = maxWidth;
8866 }
8868 if (width < SIDEBAR_MIN_WIDTH) {
8869 width = SIDEBAR_MIN_WIDTH;
8870 }
8872 if (width === this._width) {
8873 return false;
8874 }
8876 this._width = width;
8878 return true;
8879 }
8881 _mouseMove(evt) {
8882 let width = evt.clientX;
8884 if (this.isRTL) {
8885 width = this.outerContainerWidth - width;
8886 }
8888 this._updateWidth(width);
8889 }
8891 _mouseUp(evt) {
8892 this.outerContainer.classList.remove(SIDEBAR_RESIZING_CLASS);
8894 source: this
8895 });
8896 const _boundEvents = this._boundEvents;
8899 }
8901 _addEventListeners() {
8902 const _boundEvents = this._boundEvents;
8903 _boundEvents.mouseMove = this._mouseMove.bind(this);
8904 _boundEvents.mouseUp = this._mouseUp.bind(this);
8906 if (evt.button !== 0) {
8907 return;
8908 }
8910 this.outerContainer.classList.add(SIDEBAR_RESIZING_CLASS);
8913 });
8916 this.sidebarOpen = !!evt?.view;
8917 });
8920 if (evt?.source !== window) {
8921 return;
8922 }
8924 this._outerContainerWidth = null;
8926 if (!this._width) {
8927 return;
8928 }
8930 if (!this.sidebarOpen) {
8931 this._updateWidth(this._width);
8933 return;
8934 }
8936 this.outerContainer.classList.add(SIDEBAR_RESIZING_CLASS);
8938 const updated = this._updateWidth(this._width);
8940 Promise.resolve().then(() => {
8941 this.outerContainer.classList.remove(SIDEBAR_RESIZING_CLASS);
8943 if (updated) {
8945 source: this
8946 });
8947 }
8948 });
8949 });
8950 }
8952 }
8954 exports.PDFSidebarResizer = PDFSidebarResizer;
8956 /***/ }),
8957 /* 25 */
8958 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
8963 value: true
8964 }));
8965 exports.PDFThumbnailViewer = void 0;
8967 var _ui_utils = __webpack_require__(4);
8969 var _pdf_thumbnail_view = __webpack_require__(26);
8971 var _pdf_rendering_queue = __webpack_require__(8);
8973 const THUMBNAIL_SCROLL_MARGIN = -19;
8976 class PDFThumbnailViewer {
8977 constructor({
8978 container,
8979 eventBus,
8980 linkService,
8981 renderingQueue,
8982 l10n
8983 }) {
8984 this.container = container;
8985 this.linkService = linkService;
8986 this.renderingQueue = renderingQueue;
8987 this.l10n = l10n;
8988 this.scroll = (0, _ui_utils.watchScroll)(this.container, this._scrollUpdated.bind(this));
8990 this._resetView();
8993 this._setImageDisabled = true;
8994 });
8995 }
8997 _scrollUpdated() {
8998 this.renderingQueue.renderHighestPriority();
8999 }
9001 getThumbnail(index) {
9002 return this._thumbnails[index];
9003 }
9005 _getVisibleThumbs() {
9006 return (0, _ui_utils.getVisibleElements)({
9007 scrollEl: this.container,
9008 views: this._thumbnails
9009 });
9010 }
9012 scrollThumbnailIntoView(pageNumber) {
9013 if (!this.pdfDocument) {
9014 return;
9015 }
9017 const thumbnailView = this._thumbnails[pageNumber - 1];
9019 if (!thumbnailView) {
9021 return;
9022 }
9024 if (pageNumber !== this._currentPageNumber) {
9025 const prevThumbnailView = this._thumbnails[this._currentPageNumber - 1];
9026 prevThumbnailView.div.classList.remove(THUMBNAIL_SELECTED_CLASS);
9027 thumbnailView.div.classList.add(THUMBNAIL_SELECTED_CLASS);
9028 }
9030 const visibleThumbs = this._getVisibleThumbs();
9032 const numVisibleThumbs = visibleThumbs.views.length;
9034 if (numVisibleThumbs > 0) {
9035 const first = visibleThumbs.first.id;
9036 const last = numVisibleThumbs > 1 ? visibleThumbs.last.id : first;
9037 let shouldScroll = false;
9039 if (pageNumber <= first || pageNumber >= last) {
9040 shouldScroll = true;
9041 } else {
9042 visibleThumbs.views.some(function (view) {
9043 if (view.id !== pageNumber) {
9044 return false;
9045 }
9047 shouldScroll = view.percent < 100;
9048 return true;
9049 });
9050 }
9052 if (shouldScroll) {
9053 (0, _ui_utils.scrollIntoView)(thumbnailView.div, {
9054 top: THUMBNAIL_SCROLL_MARGIN
9055 });
9056 }
9057 }
9059 this._currentPageNumber = pageNumber;
9060 }
9062 get pagesRotation() {
9063 return this._pagesRotation;
9064 }
9066 set pagesRotation(rotation) {
9067 if (!(0, _ui_utils.isValidRotation)(rotation)) {
9069 }
9071 if (!this.pdfDocument) {
9072 return;
9073 }
9075 if (this._pagesRotation === rotation) {
9076 return;
9077 }
9079 this._pagesRotation = rotation;
9081 for (let i = 0, ii = this._thumbnails.length; i < ii; i++) {
9082 this._thumbnails[i].update(rotation);
9083 }
9084 }
9086 cleanup() {
9087 for (let i = 0, ii = this._thumbnails.length; i < ii; i++) {
9088 if (this._thumbnails[i] && this._thumbnails[i].renderingState !== _pdf_rendering_queue.RenderingStates.FINISHED) {
9089 this._thumbnails[i].reset();
9090 }
9091 }
9093 _pdf_thumbnail_view.TempImageFactory.destroyCanvas();
9094 }
9096 _resetView() {
9097 this._thumbnails = [];
9098 this._currentPageNumber = 1;
9099 this._pageLabels = null;
9100 this._pagesRotation = 0;
9101 this._optionalContentConfigPromise = null;
9102 this._pagesRequests = new WeakMap();
9103 this._setImageDisabled = false;
9105 }
9107 setDocument(pdfDocument) {
9108 if (this.pdfDocument) {
9109 this._cancelRendering();
9111 this._resetView();
9112 }
9114 this.pdfDocument = pdfDocument;
9116 if (!pdfDocument) {
9117 return;
9118 }
9120 const firstPagePromise = pdfDocument.getPage(1);
9121 const optionalContentConfigPromise = pdfDocument.getOptionalContentConfig();
9122 firstPagePromise.then(firstPdfPage => {
9123 this._optionalContentConfigPromise = optionalContentConfigPromise;
9124 const pagesCount = pdfDocument.numPages;
9125 const viewport = firstPdfPage.getViewport({
9126 scale: 1
9127 });
9129 const checkSetImageDisabled = () => {
9130 return this._setImageDisabled;
9131 };
9133 for (let pageNum = 1; pageNum <= pagesCount; ++pageNum) {
9134 const thumbnail = new _pdf_thumbnail_view.PDFThumbnailView({
9135 container: this.container,
9136 id: pageNum,
9137 defaultViewport: viewport.clone(),
9138 optionalContentConfigPromise,
9139 linkService: this.linkService,
9140 renderingQueue: this.renderingQueue,
9141 checkSetImageDisabled,
9142 l10n: this.l10n
9143 });
9145 this._thumbnails.push(thumbnail);
9146 }
9148 const firstThumbnailView = this._thumbnails[0];
9150 if (firstThumbnailView) {
9151 firstThumbnailView.setPdfPage(firstPdfPage);
9152 }
9154 const thumbnailView = this._thumbnails[this._currentPageNumber - 1];
9155 thumbnailView.div.classList.add(THUMBNAIL_SELECTED_CLASS);
9156 }).catch(reason => {
9158 });
9159 }
9161 _cancelRendering() {
9162 for (let i = 0, ii = this._thumbnails.length; i < ii; i++) {
9163 if (this._thumbnails[i]) {
9164 this._thumbnails[i].cancelRendering();
9165 }
9166 }
9167 }
9169 setPageLabels(labels) {
9170 if (!this.pdfDocument) {
9171 return;
9172 }
9174 if (!labels) {
9175 this._pageLabels = null;
9176 } else if (!(Array.isArray(labels) && this.pdfDocument.numPages === labels.length)) {
9177 this._pageLabels = null;
9179 } else {
9180 this._pageLabels = labels;
9181 }
9183 for (let i = 0, ii = this._thumbnails.length; i < ii; i++) {
9184 this._thumbnails[i].setPageLabel(this._pageLabels?.[i] ?? null);
9185 }
9186 }
9188 _ensurePdfPageLoaded(thumbView) {
9189 if (thumbView.pdfPage) {
9190 return Promise.resolve(thumbView.pdfPage);
9191 }
9193 if (this._pagesRequests.has(thumbView)) {
9194 return this._pagesRequests.get(thumbView);
9195 }
9197 const promise = this.pdfDocument.getPage(thumbView.id).then(pdfPage => {
9198 if (!thumbView.pdfPage) {
9199 thumbView.setPdfPage(pdfPage);
9200 }
9202 this._pagesRequests.delete(thumbView);
9204 return pdfPage;
9205 }).catch(reason => {
9208 this._pagesRequests.delete(thumbView);
9209 });
9211 this._pagesRequests.set(thumbView, promise);
9213 return promise;
9214 }
9216 forceRendering() {
9217 const visibleThumbs = this._getVisibleThumbs();
9219 const thumbView = this.renderingQueue.getHighestPriority(visibleThumbs, this._thumbnails, this.scroll.down);
9221 if (thumbView) {
9222 this._ensurePdfPageLoaded(thumbView).then(() => {
9223 this.renderingQueue.renderView(thumbView);
9224 });
9226 return true;
9227 }
9229 return false;
9230 }
9232 }
9234 exports.PDFThumbnailViewer = PDFThumbnailViewer;
9236 /***/ }),
9237 /* 26 */
9238 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
9243 value: true
9244 }));
9245 exports.TempImageFactory = exports.PDFThumbnailView = void 0;
9247 var _ui_utils = __webpack_require__(4);
9249 var _pdfjsLib = __webpack_require__(5);
9251 var _pdf_rendering_queue = __webpack_require__(8);
9253 const DRAW_UPSCALE_FACTOR = 2;
9254 const MAX_NUM_SCALING_STEPS = 3;
9255 const THUMBNAIL_CANVAS_BORDER_WIDTH = 1;
9256 const THUMBNAIL_WIDTH = 98;
9258 const TempImageFactory = function TempImageFactoryClosure() {
9259 let tempCanvasCache = null;
9260 return {
9261 getCanvas(width, height) {
9262 let tempCanvas = tempCanvasCache;
9264 if (!tempCanvas) {
9266 tempCanvasCache = tempCanvas;
9267 }
9269 tempCanvas.width = width;
9270 tempCanvas.height = height;
9271 tempCanvas.mozOpaque = true;
9273 alpha: false
9274 });
9275 ctx.save();
9277 ctx.fillRect(0, 0, width, height);
9278 ctx.restore();
9280 },
9282 destroyCanvas() {
9283 const tempCanvas = tempCanvasCache;
9285 if (tempCanvas) {
9286 tempCanvas.width = 0;
9287 tempCanvas.height = 0;
9288 }
9290 tempCanvasCache = null;
9291 }
9293 };
9294 }();
9296 exports.TempImageFactory = TempImageFactory;
9298 class PDFThumbnailView {
9299 constructor({
9300 container,
9301 id,
9302 defaultViewport,
9303 optionalContentConfigPromise,
9304 linkService,
9305 renderingQueue,
9306 checkSetImageDisabled,
9307 l10n
9308 }) {
9309 this.id = id;
9311 this.pageLabel = null;
9312 this.pdfPage = null;
9313 this.rotation = 0;
9314 this.viewport = defaultViewport;
9315 this.pdfPageRotate = defaultViewport.rotation;
9316 this._optionalContentConfigPromise = optionalContentConfigPromise || null;
9317 this.linkService = linkService;
9318 this.renderingQueue = renderingQueue;
9319 this.renderTask = null;
9320 this.renderingState = _pdf_rendering_queue.RenderingStates.INITIAL;
9321 this.resume = null;
9323 this._checkSetImageDisabled = checkSetImageDisabled || function () {
9324 return false;
9325 };
9327 const pageWidth = this.viewport.width,
9328 pageHeight = this.viewport.height,
9329 pageRatio = pageWidth / pageHeight;
9330 this.canvasWidth = THUMBNAIL_WIDTH;
9331 this.canvasHeight = this.canvasWidth / pageRatio | 0;
9332 this.scale = this.canvasWidth / pageWidth;
9333 this.l10n = l10n;
9337 this._thumbPageTitle.then(msg => {
9338 anchor.title = msg;
9339 });
9341 anchor.onclick = function () {
9342 linkService.goToPage(id);
9343 return false;
9344 };
9346 this.anchor = anchor;
9350 this.div = div;
9353 const borderAdjustment = 2 * THUMBNAIL_CANVAS_BORDER_WIDTH;
9356 this.ring = ring;
9357 div.appendChild(ring);
9358 anchor.appendChild(div);
9359 container.appendChild(anchor);
9360 }
9362 setPdfPage(pdfPage) {
9363 this.pdfPage = pdfPage;
9364 this.pdfPageRotate = pdfPage.rotate;
9365 const totalRotation = (this.rotation + this.pdfPageRotate) % 360;
9366 this.viewport = pdfPage.getViewport({
9367 scale: 1,
9368 rotation: totalRotation
9369 });
9370 this.reset();
9371 }
9373 reset() {
9374 this.cancelRendering();
9375 this.renderingState = _pdf_rendering_queue.RenderingStates.INITIAL;
9376 const pageWidth = this.viewport.width,
9377 pageHeight = this.viewport.height,
9378 pageRatio = pageWidth / pageHeight;
9379 this.canvasHeight = this.canvasWidth / pageRatio | 0;
9380 this.scale = this.canvasWidth / pageWidth;
9382 const ring = this.ring;
9384 const borderAdjustment = 2 * THUMBNAIL_CANVAS_BORDER_WIDTH;
9388 if (this.canvas) {
9389 this.canvas.width = 0;
9390 this.canvas.height = 0;
9391 delete this.canvas;
9392 }
9394 if (this.image) {
9396 delete this.image;
9397 }
9398 }
9400 update(rotation) {
9402 this.rotation = rotation;
9403 }
9405 const totalRotation = (this.rotation + this.pdfPageRotate) % 360;
9406 this.viewport = this.viewport.clone({
9407 scale: 1,
9408 rotation: totalRotation
9409 });
9410 this.reset();
9411 }
9413 cancelRendering() {
9414 if (this.renderTask) {
9415 this.renderTask.cancel();
9416 this.renderTask = null;
9417 }
9419 this.resume = null;
9420 }
9422 _getPageDrawContext(upscaleFactor = 1) {
9424 canvas.mozOpaque = true;
9426 alpha: false
9427 });
9428 const outputScale = (0, _ui_utils.getOutputScale)(ctx);
9429 canvas.width = upscaleFactor * this.canvasWidth * outputScale.sx | 0;
9430 canvas.height = upscaleFactor * this.canvasHeight * outputScale.sy | 0;
9431 const transform = outputScale.scaled ? [outputScale.sx, 0, 0, outputScale.sy, 0, 0] : null;
9432 return {
9433 ctx,
9434 canvas,
9435 transform
9436 };
9437 }
9439 _convertCanvasToImage(canvas) {
9440 if (this.renderingState !== _pdf_rendering_queue.RenderingStates.FINISHED) {
9442 }
9444 const reducedCanvas = this._reduceImage(canvas);
9449 this._thumbPageCanvas.then(msg => {
9451 });
9455 image.src = reducedCanvas.toDataURL();
9456 this.image = image;
9458 this.ring.appendChild(image);
9459 reducedCanvas.width = 0;
9460 reducedCanvas.height = 0;
9461 }
9463 draw() {
9464 if (this.renderingState !== _pdf_rendering_queue.RenderingStates.INITIAL) {
9466 return Promise.resolve(undefined);
9467 }
9469 const {
9470 pdfPage
9471 } = this;
9473 if (!pdfPage) {
9474 this.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED;
9476 }
9478 this.renderingState = _pdf_rendering_queue.RenderingStates.RUNNING;
9480 const finishRenderTask = async (error = null) => {
9481 if (renderTask === this.renderTask) {
9482 this.renderTask = null;
9483 }
9485 if (error instanceof _pdfjsLib.RenderingCancelledException) {
9486 return;
9487 }
9489 this.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED;
9491 this._convertCanvasToImage(canvas);
9493 if (error) {
9494 throw error;
9495 }
9496 };
9498 const {
9499 ctx,
9500 canvas,
9501 transform
9502 } = this._getPageDrawContext(DRAW_UPSCALE_FACTOR);
9504 const drawViewport = this.viewport.clone({
9505 scale: DRAW_UPSCALE_FACTOR * this.scale
9506 });
9508 const renderContinueCallback = cont => {
9509 if (!this.renderingQueue.isHighestPriority(this)) {
9510 this.renderingState = _pdf_rendering_queue.RenderingStates.PAUSED;
9512 this.resume = () => {
9513 this.renderingState = _pdf_rendering_queue.RenderingStates.RUNNING;
9514 cont();
9515 };
9517 return;
9518 }
9520 cont();
9521 };
9523 const renderContext = {
9524 canvasContext: ctx,
9525 transform,
9526 viewport: drawViewport,
9527 optionalContentConfigPromise: this._optionalContentConfigPromise
9528 };
9529 const renderTask = this.renderTask = pdfPage.render(renderContext);
9530 renderTask.onContinue = renderContinueCallback;
9531 const resultPromise = renderTask.promise.then(function () {
9532 return finishRenderTask(null);
9533 }, function (error) {
9534 return finishRenderTask(error);
9535 });
9536 resultPromise.finally(() => {
9537 canvas.width = 0;
9538 canvas.height = 0;
9539 const pageCached = this.linkService.isPageCached(this.id);
9541 if (!pageCached) {
9542 this.pdfPage?.cleanup();
9543 }
9544 });
9545 return resultPromise;
9546 }
9548 setImage(pageView) {
9549 if (this._checkSetImageDisabled()) {
9550 return;
9551 }
9553 if (this.renderingState !== _pdf_rendering_queue.RenderingStates.INITIAL) {
9554 return;
9555 }
9557 const {
9558 canvas,
9559 pdfPage
9560 } = pageView;
9562 if (!canvas) {
9563 return;
9564 }
9566 if (!this.pdfPage) {
9567 this.setPdfPage(pdfPage);
9568 }
9570 this.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED;
9572 this._convertCanvasToImage(canvas);
9573 }
9575 _reduceImage(img) {
9576 const {
9577 ctx,
9578 canvas
9579 } = this._getPageDrawContext();
9581 if (img.width <= 2 * canvas.width) {
9582 ctx.drawImage(img, 0, 0, img.width, img.height, 0, 0, canvas.width, canvas.height);
9583 return canvas;
9584 }
9586 let reducedWidth = canvas.width << MAX_NUM_SCALING_STEPS;
9587 let reducedHeight = canvas.height << MAX_NUM_SCALING_STEPS;
9588 const [reducedImage, reducedImageCtx] = TempImageFactory.getCanvas(reducedWidth, reducedHeight);
9590 while (reducedWidth > img.width || reducedHeight > img.height) {
9591 reducedWidth >>= 1;
9592 reducedHeight >>= 1;
9593 }
9595 reducedImageCtx.drawImage(img, 0, 0, img.width, img.height, 0, 0, reducedWidth, reducedHeight);
9597 while (reducedWidth > 2 * canvas.width) {
9598 reducedImageCtx.drawImage(reducedImage, 0, 0, reducedWidth, reducedHeight, 0, 0, reducedWidth >> 1, reducedHeight >> 1);
9599 reducedWidth >>= 1;
9600 reducedHeight >>= 1;
9601 }
9603 ctx.drawImage(reducedImage, 0, 0, reducedWidth, reducedHeight, 0, 0, canvas.width, canvas.height);
9604 return canvas;
9605 }
9607 get _thumbPageTitle() {
9609 page: this.pageLabel ?? this.id
9610 });
9611 }
9613 get _thumbPageCanvas() {
9615 page: this.pageLabel ?? this.id
9616 });
9617 }
9619 setPageLabel(label) {
9622 this._thumbPageTitle.then(msg => {
9623 this.anchor.title = msg;
9624 });
9626 if (this.renderingState !== _pdf_rendering_queue.RenderingStates.FINISHED) {
9627 return;
9628 }
9630 this._thumbPageCanvas.then(msg => {
9632 });
9633 }
9635 }
9637 exports.PDFThumbnailView = PDFThumbnailView;
9639 /***/ }),
9640 /* 27 */
9641 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
9646 value: true
9647 }));
9648 exports.PDFViewer = void 0;
9650 var _ui_utils = __webpack_require__(4);
9652 var _base_viewer = __webpack_require__(28);
9654 var _pdfjsLib = __webpack_require__(5);
9656 class PDFViewer extends _base_viewer.BaseViewer {
9657 get _viewerElement() {
9659 }
9661 _scrollIntoView({
9662 pageDiv,
9663 pageSpot = null,
9664 pageNumber = null
9665 }) {
9666 if (!pageSpot && !this.isInPresentationMode) {
9667 const left = pageDiv.offsetLeft + pageDiv.clientLeft;
9668 const right = left + pageDiv.clientWidth;
9669 const {
9670 scrollLeft,
9671 clientWidth
9672 } = this.container;
9674 if (this._isScrollModeHorizontal || left < scrollLeft || right > scrollLeft + clientWidth) {
9675 pageSpot = {
9676 left: 0,
9677 top: 0
9678 };
9679 }
9680 }
9682 super._scrollIntoView({
9683 pageDiv,
9684 pageSpot,
9685 pageNumber
9686 });
9687 }
9689 _getVisiblePages() {
9690 if (this.isInPresentationMode) {
9691 return this._getCurrentVisiblePage();
9692 }
9694 return super._getVisiblePages();
9695 }
9697 _updateHelper(visiblePages) {
9698 if (this.isInPresentationMode) {
9699 return;
9700 }
9702 let currentId = this._currentPageNumber;
9703 let stillFullyVisible = false;
9705 for (const page of visiblePages) {
9706 if (page.percent < 100) {
9707 break;
9708 }
9710 if (page.id === currentId && this._scrollMode === _ui_utils.ScrollMode.VERTICAL && this._spreadMode === _ui_utils.SpreadMode.NONE) {
9711 stillFullyVisible = true;
9712 break;
9713 }
9714 }
9716 if (!stillFullyVisible) {
9717 currentId = visiblePages[0].id;
9718 }
9720 this._setCurrentPageNumber(currentId);
9721 }
9723 }
9725 exports.PDFViewer = PDFViewer;
9727 /***/ }),
9728 /* 28 */
9729 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
9734 value: true
9735 }));
9736 exports.BaseViewer = void 0;
9738 var _pdfjsLib = __webpack_require__(5);
9740 var _ui_utils = __webpack_require__(4);
9742 var _pdf_rendering_queue = __webpack_require__(8);
9744 var _annotation_layer_builder = __webpack_require__(29);
9746 var _l10n_utils = __webpack_require__(30);
9748 var _pdf_page_view = __webpack_require__(31);
9750 var _pdf_link_service = __webpack_require__(19);
9752 var _struct_tree_layer_builder = __webpack_require__(32);
9754 var _text_layer_builder = __webpack_require__(33);
9756 var _xfa_layer_builder = __webpack_require__(34);
9758 const DEFAULT_CACHE_SIZE = 10;
9760 function PDFPageViewBuffer(size) {
9761 const data = [];
9763 this.push = function (view) {
9764 const i = data.indexOf(view);
9766 if (i >= 0) {
9767 data.splice(i, 1);
9768 }
9770 data.push(view);
9772 if (data.length > size) {
9773 data.shift().destroy();
9774 }
9775 };
9777 this.resize = function (newSize, pagesToKeep) {
9778 size = newSize;
9780 if (pagesToKeep) {
9781 const pageIdsToKeep = new Set();
9783 for (let i = 0, iMax = pagesToKeep.length; i < iMax; ++i) {
9784 pageIdsToKeep.add(pagesToKeep[i].id);
9785 }
9787 (0, _ui_utils.moveToEndOfArray)(data, function (page) {
9788 return pageIdsToKeep.has(page.id);
9789 });
9790 }
9792 while (data.length > size) {
9793 data.shift().destroy();
9794 }
9795 };
9797 this.has = function (view) {
9798 return data.includes(view);
9799 };
9800 }
9802 function isSameScale(oldScale, newScale) {
9803 if (newScale === oldScale) {
9804 return true;
9805 }
9807 if (Math.abs(newScale - oldScale) < 1e-15) {
9808 return true;
9809 }
9811 return false;
9812 }
9814 class BaseViewer {
9815 constructor(options) {
9816 if (this.constructor === BaseViewer) {
9818 }
9820 const viewerVersion = '2.10.377';
9822 if (_pdfjsLib.version !== viewerVersion) {
9823 throw new Error(`The API version "${_pdfjsLib.version}" does not match the Viewer version "${viewerVersion}".`);
9824 }
9826 this._name = this.constructor.name;
9827 this.container = options.container;
9828 this.viewer = options.viewer || options.container.firstElementChild;
9830 if (!(this.container?.tagName.toUpperCase() === "DIV" && this.viewer?.tagName.toUpperCase() === "DIV")) {
9832 }
9836 }
9838 this.eventBus = options.eventBus;
9839 this.linkService = options.linkService || new _pdf_link_service.SimpleLinkService();
9840 this.downloadManager = options.downloadManager || null;
9841 this.findController = options.findController || null;
9842 this._scriptingManager = options.scriptingManager || null;
9843 this.removePageBorders = options.removePageBorders || false;
9844 this.textLayerMode = Number.isInteger(options.textLayerMode) ? options.textLayerMode : _ui_utils.TextLayerMode.ENABLE;
9846 this.renderInteractiveForms = options.renderInteractiveForms !== false;
9847 this.enablePrintAutoRotate = options.enablePrintAutoRotate || false;
9848 this.renderer = options.renderer || _ui_utils.RendererType.CANVAS;
9849 this.useOnlyCssZoom = options.useOnlyCssZoom || false;
9850 this.maxCanvasPixels = options.maxCanvasPixels;
9851 this.l10n = options.l10n || _l10n_utils.NullL10n;
9852 this.enableScripting = options.enableScripting === true && !!this._scriptingManager;
9853 this.defaultRenderingQueue = !options.renderingQueue;
9855 if (this.defaultRenderingQueue) {
9856 this.renderingQueue = new _pdf_rendering_queue.PDFRenderingQueue();
9857 this.renderingQueue.setViewer(this);
9858 } else {
9859 this.renderingQueue = options.renderingQueue;
9860 }
9862 this.scroll = (0, _ui_utils.watchScroll)(this.container, this._scrollUpdate.bind(this));
9863 this.presentationModeState = _ui_utils.PresentationModeState.UNKNOWN;
9864 this._onBeforeDraw = this._onAfterDraw = null;
9866 this._resetView();
9868 if (this.removePageBorders) {
9870 }
9872 Promise.resolve().then(() => {
9874 source: this
9875 });
9876 });
9877 }
9879 get pagesCount() {
9880 return this._pages.length;
9881 }
9883 getPageView(index) {
9884 return this._pages[index];
9885 }
9887 get pageViewsReady() {
9888 if (!this._pagesCapability.settled) {
9889 return false;
9890 }
9892 return this._pages.every(function (pageView) {
9893 return pageView?.pdfPage;
9894 });
9895 }
9897 get currentPageNumber() {
9898 return this._currentPageNumber;
9899 }
9901 set currentPageNumber(val) {
9902 if (!Number.isInteger(val)) {
9904 }
9906 if (!this.pdfDocument) {
9907 return;
9908 }
9910 if (!this._setCurrentPageNumber(val, true)) {
9912 }
9913 }
9915 _setCurrentPageNumber(val, resetCurrentPageView = false) {
9916 if (this._currentPageNumber === val) {
9917 if (resetCurrentPageView) {
9918 this._resetCurrentPageView();
9919 }
9921 return true;
9922 }
9924 if (!(0 < val && val <= this.pagesCount)) {
9925 return false;
9926 }
9928 const previous = this._currentPageNumber;
9929 this._currentPageNumber = val;
9931 source: this,
9932 pageNumber: val,
9933 pageLabel: this._pageLabels?.[val - 1] ?? null,
9934 previous
9935 });
9937 if (resetCurrentPageView) {
9938 this._resetCurrentPageView();
9939 }
9941 return true;
9942 }
9944 get currentPageLabel() {
9945 return this._pageLabels?.[this._currentPageNumber - 1] ?? null;
9946 }
9948 set currentPageLabel(val) {
9949 if (!this.pdfDocument) {
9950 return;
9951 }
9953 let page = val | 0;
9955 if (this._pageLabels) {
9956 const i = this._pageLabels.indexOf(val);
9958 if (i >= 0) {
9959 page = i + 1;
9960 }
9961 }
9963 if (!this._setCurrentPageNumber(page, true)) {
9965 }
9966 }
9968 get currentScale() {
9969 return this._currentScale !== _ui_utils.UNKNOWN_SCALE ? this._currentScale : _ui_utils.DEFAULT_SCALE;
9970 }
9972 set currentScale(val) {
9973 if (isNaN(val)) {
9975 }
9977 if (!this.pdfDocument) {
9978 return;
9979 }
9981 this._setScale(val, false);
9982 }
9984 get currentScaleValue() {
9985 return this._currentScaleValue;
9986 }
9988 set currentScaleValue(val) {
9989 if (!this.pdfDocument) {
9990 return;
9991 }
9993 this._setScale(val, false);
9994 }
9996 get pagesRotation() {
9997 return this._pagesRotation;
9998 }
10000 set pagesRotation(rotation) {
10001 if (!(0, _ui_utils.isValidRotation)(rotation)) {
10003 }
10005 if (!this.pdfDocument) {
10006 return;
10007 }
10009 rotation %= 360;
10011 if (rotation < 0) {
10012 rotation += 360;
10013 }
10015 if (this._pagesRotation === rotation) {
10016 return;
10017 }
10019 this._pagesRotation = rotation;
10020 const pageNumber = this._currentPageNumber;
10022 for (let i = 0, ii = this._pages.length; i < ii; i++) {
10023 const pageView = this._pages[i];
10024 pageView.update(pageView.scale, rotation);
10025 }
10027 if (this._currentScaleValue) {
10028 this._setScale(this._currentScaleValue, true);
10029 }
10032 source: this,
10033 pagesRotation: rotation,
10034 pageNumber
10035 });
10037 if (this.defaultRenderingQueue) {
10038 this.update();
10039 }
10040 }
10042 get firstPagePromise() {
10043 return this.pdfDocument ? this._firstPageCapability.promise : null;
10044 }
10046 get onePageRendered() {
10047 return this.pdfDocument ? this._onePageRenderedCapability.promise : null;
10048 }
10050 get pagesPromise() {
10051 return this.pdfDocument ? this._pagesCapability.promise : null;
10052 }
10054 get _viewerElement() {
10056 }
10058 _onePageRenderedOrForceFetch() {
10059 if (!this.container.offsetParent || this._getVisiblePages().views.length === 0) {
10060 return Promise.resolve();
10061 }
10063 return this._onePageRenderedCapability.promise;
10064 }
10066 setDocument(pdfDocument) {
10067 if (this.pdfDocument) {
10069 source: this
10070 });
10072 this._cancelRendering();
10074 this._resetView();
10076 if (this.findController) {
10077 this.findController.setDocument(null);
10078 }
10080 if (this._scriptingManager) {
10081 this._scriptingManager.setDocument(null);
10082 }
10083 }
10085 this.pdfDocument = pdfDocument;
10087 if (!pdfDocument) {
10088 return;
10089 }
10091 const isPureXfa = pdfDocument.isPureXfa;
10092 const pagesCount = pdfDocument.numPages;
10093 const firstPagePromise = pdfDocument.getPage(1);
10094 const optionalContentConfigPromise = pdfDocument.getOptionalContentConfig();
10096 this._pagesCapability.promise.then(() => {
10098 source: this,
10099 pagesCount
10100 });
10101 });
10103 this._onBeforeDraw = evt => {
10104 const pageView = this._pages[evt.pageNumber - 1];
10106 if (!pageView) {
10107 return;
10108 }
10110 this._buffer.push(pageView);
10111 };
10115 this._onAfterDraw = evt => {
10116 if (evt.cssTransform || this._onePageRenderedCapability.settled) {
10117 return;
10118 }
10120 this._onePageRenderedCapability.resolve();
10124 this._onAfterDraw = null;
10125 };
10129 firstPagePromise.then(firstPdfPage => {
10130 this._firstPageCapability.resolve(firstPdfPage);
10132 this._optionalContentConfigPromise = optionalContentConfigPromise;
10133 const scale = this.currentScale;
10134 const viewport = firstPdfPage.getViewport({
10135 scale: scale * _ui_utils.CSS_UNITS
10136 });
10137 const textLayerFactory = this.textLayerMode !== _ui_utils.TextLayerMode.DISABLE ? this : null;
10138 const xfaLayerFactory = isPureXfa ? this : null;
10140 for (let pageNum = 1; pageNum <= pagesCount; ++pageNum) {
10141 const pageView = new _pdf_page_view.PDFPageView({
10142 container: this._viewerElement,
10143 eventBus: this.eventBus,
10144 id: pageNum,
10145 scale,
10146 defaultViewport: viewport.clone(),
10147 optionalContentConfigPromise,
10148 renderingQueue: this.renderingQueue,
10149 textLayerFactory,
10150 textLayerMode: this.textLayerMode,
10151 annotationLayerFactory: this,
10152 xfaLayerFactory,
10153 structTreeLayerFactory: this,
10154 imageResourcesPath: this.imageResourcesPath,
10155 renderInteractiveForms: this.renderInteractiveForms,
10156 renderer: this.renderer,
10157 useOnlyCssZoom: this.useOnlyCssZoom,
10158 maxCanvasPixels: this.maxCanvasPixels,
10159 l10n: this.l10n
10160 });
10162 this._pages.push(pageView);
10163 }
10165 const firstPageView = this._pages[0];
10167 if (firstPageView) {
10168 firstPageView.setPdfPage(firstPdfPage);
10169 this.linkService.cachePageRef(1, firstPdfPage.ref);
10170 }
10172 if (this._spreadMode !== _ui_utils.SpreadMode.NONE) {
10173 this._updateSpreadMode();
10174 }
10176 this._onePageRenderedOrForceFetch().then(() => {
10177 if (this.findController) {
10178 this.findController.setDocument(pdfDocument);
10179 }
10181 if (this.enableScripting) {
10182 this._scriptingManager.setDocument(pdfDocument);
10183 }
10185 if (pdfDocument.loadingParams.disableAutoFetch || pagesCount > 7500) {
10186 this._pagesCapability.resolve();
10188 return;
10189 }
10191 let getPagesLeft = pagesCount - 1;
10193 if (getPagesLeft <= 0) {
10194 this._pagesCapability.resolve();
10196 return;
10197 }
10199 for (let pageNum = 2; pageNum <= pagesCount; ++pageNum) {
10200 pdfDocument.getPage(pageNum).then(pdfPage => {
10201 const pageView = this._pages[pageNum - 1];
10203 if (!pageView.pdfPage) {
10204 pageView.setPdfPage(pdfPage);
10205 }
10207 this.linkService.cachePageRef(pageNum, pdfPage.ref);
10209 if (--getPagesLeft === 0) {
10210 this._pagesCapability.resolve();
10211 }
10212 }, reason => {
10215 if (--getPagesLeft === 0) {
10216 this._pagesCapability.resolve();
10217 }
10218 });
10219 }
10220 });
10223 source: this
10224 });
10226 if (this.defaultRenderingQueue) {
10227 this.update();
10228 }
10229 }).catch(reason => {
10231 });
10232 }
10234 setPageLabels(labels) {
10235 if (!this.pdfDocument) {
10236 return;
10237 }
10239 if (!labels) {
10240 this._pageLabels = null;
10241 } else if (!(Array.isArray(labels) && this.pdfDocument.numPages === labels.length)) {
10242 this._pageLabels = null;
10244 } else {
10245 this._pageLabels = labels;
10246 }
10248 for (let i = 0, ii = this._pages.length; i < ii; i++) {
10249 this._pages[i].setPageLabel(this._pageLabels?.[i] ?? null);
10250 }
10251 }
10253 _resetView() {
10254 this._pages = [];
10255 this._currentPageNumber = 1;
10256 this._currentScale = _ui_utils.UNKNOWN_SCALE;
10257 this._currentScaleValue = null;
10258 this._pageLabels = null;
10259 this._buffer = new PDFPageViewBuffer(DEFAULT_CACHE_SIZE);
10260 this._location = null;
10261 this._pagesRotation = 0;
10262 this._optionalContentConfigPromise = null;
10263 this._pagesRequests = new WeakMap();
10264 this._firstPageCapability = (0, _pdfjsLib.createPromiseCapability)();
10265 this._onePageRenderedCapability = (0, _pdfjsLib.createPromiseCapability)();
10266 this._pagesCapability = (0, _pdfjsLib.createPromiseCapability)();
10267 this._scrollMode = _ui_utils.ScrollMode.VERTICAL;
10268 this._spreadMode = _ui_utils.SpreadMode.NONE;
10270 if (this._onBeforeDraw) {
10273 this._onBeforeDraw = null;
10274 }
10276 if (this._onAfterDraw) {
10279 this._onAfterDraw = null;
10280 }
10284 this._updateScrollMode();
10285 }
10287 _scrollUpdate() {
10288 if (this.pagesCount === 0) {
10289 return;
10290 }
10292 this.update();
10293 }
10295 _scrollIntoView({
10296 pageDiv,
10297 pageSpot = null,
10298 pageNumber = null
10299 }) {
10300 (0, _ui_utils.scrollIntoView)(pageDiv, pageSpot);
10301 }
10303 _setScaleUpdatePages(newScale, newValue, noScroll = false, preset = false) {
10304 this._currentScaleValue = newValue.toString();
10306 if (isSameScale(this._currentScale, newScale)) {
10307 if (preset) {
10309 source: this,
10310 scale: newScale,
10311 presetValue: newValue
10312 });
10313 }
10315 return;
10316 }
10318 for (let i = 0, ii = this._pages.length; i < ii; i++) {
10319 this._pages[i].update(newScale);
10320 }
10322 this._currentScale = newScale;
10324 if (!noScroll) {
10325 let page = this._currentPageNumber,
10326 dest;
10328 if (this._location && !(this.isInPresentationMode || this.isChangingPresentationMode)) {
10329 page = this._location.pageNumber;
10330 dest = [null, {
10332 }, this._location.left, this._location.top, null];
10333 }
10335 this.scrollPageIntoView({
10336 pageNumber: page,
10337 destArray: dest,
10338 allowNegativeOffset: true
10339 });
10340 }
10343 source: this,
10344 scale: newScale,
10345 presetValue: preset ? newValue : undefined
10346 });
10348 if (this.defaultRenderingQueue) {
10349 this.update();
10350 }
10351 }
10353 get _pageWidthScaleFactor() {
10354 if (this._spreadMode !== _ui_utils.SpreadMode.NONE && this._scrollMode !== _ui_utils.ScrollMode.HORIZONTAL && !this.isInPresentationMode) {
10355 return 2;
10356 }
10358 return 1;
10359 }
10361 _setScale(value, noScroll = false) {
10362 let scale = parseFloat(value);
10364 if (scale > 0) {
10365 this._setScaleUpdatePages(scale, value, noScroll, false);
10366 } else {
10367 const currentPage = this._pages[this._currentPageNumber - 1];
10369 if (!currentPage) {
10370 return;
10371 }
10373 const noPadding = this.isInPresentationMode || this.removePageBorders;
10374 let hPadding = noPadding ? 0 : _ui_utils.SCROLLBAR_PADDING;
10375 let vPadding = noPadding ? 0 : _ui_utils.VERTICAL_PADDING;
10377 if (!noPadding && this._isScrollModeHorizontal) {
10378 [hPadding, vPadding] = [vPadding, hPadding];
10379 }
10381 const pageWidthScale = (this.container.clientWidth - hPadding) / currentPage.width * currentPage.scale / this._pageWidthScaleFactor;
10382 const pageHeightScale = (this.container.clientHeight - vPadding) / currentPage.height * currentPage.scale;
10384 switch (value) {
10386 scale = 1;
10387 break;
10390 scale = pageWidthScale;
10391 break;
10394 scale = pageHeightScale;
10395 break;
10398 scale = Math.min(pageWidthScale, pageHeightScale);
10399 break;
10402 const horizontalScale = (0, _ui_utils.isPortraitOrientation)(currentPage) ? pageWidthScale : Math.min(pageHeightScale, pageWidthScale);
10403 scale = Math.min(_ui_utils.MAX_AUTO_SCALE, horizontalScale);
10404 break;
10406 default:
10408 return;
10409 }
10411 this._setScaleUpdatePages(scale, value, noScroll, true);
10412 }
10413 }
10415 _resetCurrentPageView() {
10416 if (this.isInPresentationMode) {
10417 this._setScale(this._currentScaleValue, true);
10418 }
10420 const pageView = this._pages[this._currentPageNumber - 1];
10422 this._scrollIntoView({
10423 pageDiv: pageView.div
10424 });
10425 }
10427 pageLabelToPageNumber(label) {
10428 if (!this._pageLabels) {
10429 return null;
10430 }
10432 const i = this._pageLabels.indexOf(label);
10434 if (i < 0) {
10435 return null;
10436 }
10438 return i + 1;
10439 }
10441 scrollPageIntoView({
10442 pageNumber,
10443 destArray = null,
10444 allowNegativeOffset = false,
10445 ignoreDestinationZoom = false
10446 }) {
10447 if (!this.pdfDocument) {
10448 return;
10449 }
10451 const pageView = Number.isInteger(pageNumber) && this._pages[pageNumber - 1];
10453 if (!pageView) {
10454 console.error(`${this._name}.scrollPageIntoView: ` + `"${pageNumber}" is not a valid pageNumber parameter.`);
10455 return;
10456 }
10458 if (this.isInPresentationMode || !destArray) {
10459 this._setCurrentPageNumber(pageNumber, true);
10461 return;
10462 }
10464 let x = 0,
10465 y = 0;
10466 let width = 0,
10467 height = 0,
10468 widthScale,
10469 heightScale;
10470 const changeOrientation = pageView.rotation % 180 !== 0;
10471 const pageWidth = (changeOrientation ? pageView.height : pageView.width) / pageView.scale / _ui_utils.CSS_UNITS;
10472 const pageHeight = (changeOrientation ? pageView.width : pageView.height) / pageView.scale / _ui_utils.CSS_UNITS;
10473 let scale = 0;
10475 switch (destArray[1].name) {
10477 x = destArray[2];
10478 y = destArray[3];
10479 scale = destArray[4];
10480 x = x !== null ? x : 0;
10481 y = y !== null ? y : pageHeight;
10482 break;
10487 break;
10491 y = destArray[2];
10494 if (y === null && this._location) {
10495 x = this._location.left;
10496 y = this._location.top;
10498 y = pageHeight;
10499 }
10501 break;
10505 x = destArray[2];
10506 width = pageWidth;
10507 height = pageHeight;
10509 break;
10512 x = destArray[2];
10513 y = destArray[3];
10514 width = destArray[4] - x;
10515 height = destArray[5] - y;
10516 const hPadding = this.removePageBorders ? 0 : _ui_utils.SCROLLBAR_PADDING;
10517 const vPadding = this.removePageBorders ? 0 : _ui_utils.VERTICAL_PADDING;
10518 widthScale = (this.container.clientWidth - hPadding) / width / _ui_utils.CSS_UNITS;
10519 heightScale = (this.container.clientHeight - vPadding) / height / _ui_utils.CSS_UNITS;
10520 scale = Math.min(Math.abs(widthScale), Math.abs(heightScale));
10521 break;
10523 default:
10524 console.error(`${this._name}.scrollPageIntoView: ` + `"${destArray[1].name}" is not a valid destination type.`);
10525 return;
10526 }
10528 if (!ignoreDestinationZoom) {
10529 if (scale && scale !== this._currentScale) {
10530 this.currentScaleValue = scale;
10531 } else if (this._currentScale === _ui_utils.UNKNOWN_SCALE) {
10532 this.currentScaleValue = _ui_utils.DEFAULT_SCALE_VALUE;
10533 }
10534 }
10537 this._scrollIntoView({
10538 pageDiv: pageView.div,
10539 pageNumber
10540 });
10542 return;
10543 }
10545 const boundingRect = [pageView.viewport.convertToViewportPoint(x, y), pageView.viewport.convertToViewportPoint(x + width, y + height)];
10546 let left = Math.min(boundingRect[0][0], boundingRect[1][0]);
10547 let top = Math.min(boundingRect[0][1], boundingRect[1][1]);
10549 if (!allowNegativeOffset) {
10550 left = Math.max(left, 0);
10551 top = Math.max(top, 0);
10552 }
10554 this._scrollIntoView({
10555 pageDiv: pageView.div,
10556 pageSpot: {
10557 left,
10558 top
10559 },
10560 pageNumber
10561 });
10562 }
10564 _updateLocation(firstPage) {
10565 const currentScale = this._currentScale;
10566 const currentScaleValue = this._currentScaleValue;
10567 const normalizedScaleValue = parseFloat(currentScaleValue) === currentScale ? Math.round(currentScale * 10000) / 100 : currentScaleValue;
10568 const pageNumber = firstPage.id;
10571 const currentPageView = this._pages[pageNumber - 1];
10572 const container = this.container;
10573 const topLeft = currentPageView.getPagePoint(container.scrollLeft - firstPage.x, container.scrollTop - firstPage.y);
10574 const intLeft = Math.round(topLeft[0]);
10575 const intTop = Math.round(topLeft[1]);
10577 this._location = {
10578 pageNumber,
10579 scale: normalizedScaleValue,
10580 top: intTop,
10581 left: intLeft,
10582 rotation: this._pagesRotation,
10583 pdfOpenParams
10584 };
10585 }
10587 _updateHelper(visiblePages) {
10589 }
10591 update() {
10592 const visible = this._getVisiblePages();
10594 const visiblePages = visible.views,
10595 numVisiblePages = visiblePages.length;
10597 if (numVisiblePages === 0) {
10598 return;
10599 }
10601 const newCacheSize = Math.max(DEFAULT_CACHE_SIZE, 2 * numVisiblePages + 1);
10603 this._buffer.resize(newCacheSize, visiblePages);
10605 this.renderingQueue.renderHighestPriority(visible);
10607 this._updateHelper(visiblePages);
10609 this._updateLocation(visible.first);
10612 source: this,
10613 location: this._location
10614 });
10615 }
10617 containsElement(element) {
10618 return this.container.contains(element);
10619 }
10621 focus() {
10622 this.container.focus();
10623 }
10625 get _isScrollModeHorizontal() {
10626 return this.isInPresentationMode ? false : this._scrollMode === _ui_utils.ScrollMode.HORIZONTAL;
10627 }
10629 get _isContainerRtl() {
10631 }
10633 get isInPresentationMode() {
10634 return this.presentationModeState === _ui_utils.PresentationModeState.FULLSCREEN;
10635 }
10637 get isChangingPresentationMode() {
10638 return this.presentationModeState === _ui_utils.PresentationModeState.CHANGING;
10639 }
10641 get isHorizontalScrollbarEnabled() {
10642 return this.isInPresentationMode ? false : this.container.scrollWidth > this.container.clientWidth;
10643 }
10645 get isVerticalScrollbarEnabled() {
10646 return this.isInPresentationMode ? false : this.container.scrollHeight > this.container.clientHeight;
10647 }
10649 _getCurrentVisiblePage() {
10650 if (!this.pagesCount) {
10651 return {
10652 views: []
10653 };
10654 }
10656 const pageView = this._pages[this._currentPageNumber - 1];
10657 const element = pageView.div;
10658 const view = {
10659 id: pageView.id,
10660 x: element.offsetLeft + element.clientLeft,
10661 y: element.offsetTop + element.clientTop,
10662 view: pageView
10663 };
10664 return {
10665 first: view,
10666 last: view,
10667 views: [view]
10668 };
10669 }
10671 _getVisiblePages() {
10672 return (0, _ui_utils.getVisibleElements)({
10673 scrollEl: this.container,
10674 views: this._pages,
10675 sortByVisibility: true,
10676 horizontal: this._isScrollModeHorizontal,
10677 rtl: this._isScrollModeHorizontal && this._isContainerRtl
10678 });
10679 }
10681 isPageVisible(pageNumber) {
10682 if (!this.pdfDocument) {
10683 return false;
10684 }
10686 if (!(Number.isInteger(pageNumber) && pageNumber > 0 && pageNumber <= this.pagesCount)) {
10688 return false;
10689 }
10691 return this._getVisiblePages().views.some(function (view) {
10692 return view.id === pageNumber;
10693 });
10694 }
10696 isPageCached(pageNumber) {
10697 if (!this.pdfDocument || !this._buffer) {
10698 return false;
10699 }
10701 if (!(Number.isInteger(pageNumber) && pageNumber > 0 && pageNumber <= this.pagesCount)) {
10703 return false;
10704 }
10706 const pageView = this._pages[pageNumber - 1];
10708 if (!pageView) {
10709 return false;
10710 }
10712 return this._buffer.has(pageView);
10713 }
10715 cleanup() {
10716 for (let i = 0, ii = this._pages.length; i < ii; i++) {
10717 if (this._pages[i] && this._pages[i].renderingState !== _pdf_rendering_queue.RenderingStates.FINISHED) {
10718 this._pages[i].reset();
10719 }
10720 }
10721 }
10723 _cancelRendering() {
10724 for (let i = 0, ii = this._pages.length; i < ii; i++) {
10725 if (this._pages[i]) {
10726 this._pages[i].cancelRendering();
10727 }
10728 }
10729 }
10731 _ensurePdfPageLoaded(pageView) {
10732 if (pageView.pdfPage) {
10733 return Promise.resolve(pageView.pdfPage);
10734 }
10736 if (this._pagesRequests.has(pageView)) {
10737 return this._pagesRequests.get(pageView);
10738 }
10740 const promise = this.pdfDocument.getPage(pageView.id).then(pdfPage => {
10741 if (!pageView.pdfPage) {
10742 pageView.setPdfPage(pdfPage);
10743 }
10745 this._pagesRequests.delete(pageView);
10747 return pdfPage;
10748 }).catch(reason => {
10751 this._pagesRequests.delete(pageView);
10752 });
10754 this._pagesRequests.set(pageView, promise);
10756 return promise;
10757 }
10759 forceRendering(currentlyVisiblePages) {
10760 const visiblePages = currentlyVisiblePages || this._getVisiblePages();
10762 const scrollAhead = this._isScrollModeHorizontal ? this.scroll.right : this.scroll.down;
10763 const pageView = this.renderingQueue.getHighestPriority(visiblePages, this._pages, scrollAhead);
10765 if (pageView) {
10766 this._ensurePdfPageLoaded(pageView).then(() => {
10767 this.renderingQueue.renderView(pageView);
10768 });
10770 return true;
10771 }
10773 return false;
10774 }
10776 createTextLayerBuilder(textLayerDiv, pageIndex, viewport, enhanceTextSelection = false, eventBus) {
10777 return new _text_layer_builder.TextLayerBuilder({
10778 textLayerDiv,
10779 eventBus,
10780 pageIndex,
10781 viewport,
10782 findController: this.isInPresentationMode ? null : this.findController,
10783 enhanceTextSelection: this.isInPresentationMode ? false : enhanceTextSelection
10784 });
10785 }
10787 createAnnotationLayerBuilder(pageDiv, pdfPage, annotationStorage = null, imageResourcesPath = "", renderInteractiveForms = false, l10n = _l10n_utils.NullL10n, enableScripting = null, hasJSActionsPromise = null, mouseState = null) {
10788 return new _annotation_layer_builder.AnnotationLayerBuilder({
10789 pageDiv,
10790 pdfPage,
10791 annotationStorage: annotationStorage || this.pdfDocument?.annotationStorage,
10792 imageResourcesPath,
10793 renderInteractiveForms,
10794 linkService: this.linkService,
10795 downloadManager: this.downloadManager,
10796 l10n,
10797 enableScripting: enableScripting ?? this.enableScripting,
10798 hasJSActionsPromise: hasJSActionsPromise || this.pdfDocument?.hasJSActions(),
10799 mouseState: mouseState || this._scriptingManager?.mouseState
10800 });
10801 }
10803 createXfaLayerBuilder(pageDiv, pdfPage, annotationStorage = null) {
10804 return new _xfa_layer_builder.XfaLayerBuilder({
10805 pageDiv,
10806 pdfPage,
10807 annotationStorage: annotationStorage || this.pdfDocument?.annotationStorage
10808 });
10809 }
10811 createStructTreeLayerBuilder(pdfPage) {
10812 return new _struct_tree_layer_builder.StructTreeLayerBuilder({
10813 pdfPage
10814 });
10815 }
10817 get hasEqualPageSizes() {
10818 const firstPageView = this._pages[0];
10820 for (let i = 1, ii = this._pages.length; i < ii; ++i) {
10821 const pageView = this._pages[i];
10823 if (pageView.width !== firstPageView.width || pageView.height !== firstPageView.height) {
10824 return false;
10825 }
10826 }
10828 return true;
10829 }
10831 getPagesOverview() {
10832 return this._pages.map(pageView => {
10833 const viewport = pageView.pdfPage.getViewport({
10834 scale: 1
10835 });
10837 if (!this.enablePrintAutoRotate || (0, _ui_utils.isPortraitOrientation)(viewport)) {
10838 return {
10839 width: viewport.width,
10840 height: viewport.height,
10841 rotation: viewport.rotation
10842 };
10843 }
10845 return {
10846 width: viewport.height,
10847 height: viewport.width,
10848 rotation: (viewport.rotation - 90) % 360
10849 };
10850 });
10851 }
10853 get optionalContentConfigPromise() {
10854 if (!this.pdfDocument) {
10855 return Promise.resolve(null);
10856 }
10858 if (!this._optionalContentConfigPromise) {
10859 return this.pdfDocument.getOptionalContentConfig();
10860 }
10862 return this._optionalContentConfigPromise;
10863 }
10865 set optionalContentConfigPromise(promise) {
10866 if (!(promise instanceof Promise)) {
10868 }
10870 if (!this.pdfDocument) {
10871 return;
10872 }
10874 if (!this._optionalContentConfigPromise) {
10875 return;
10876 }
10878 this._optionalContentConfigPromise = promise;
10880 for (const pageView of this._pages) {
10881 pageView.update(pageView.scale, pageView.rotation, promise);
10882 }
10884 this.update();
10886 source: this,
10887 promise
10888 });
10889 }
10891 get scrollMode() {
10892 return this._scrollMode;
10893 }
10895 set scrollMode(mode) {
10896 if (this._scrollMode === mode) {
10897 return;
10898 }
10900 if (!(0, _ui_utils.isValidScrollMode)(mode)) {
10902 }
10904 this._scrollMode = mode;
10906 source: this,
10907 mode
10908 });
10910 this._updateScrollMode(this._currentPageNumber);
10911 }
10913 _updateScrollMode(pageNumber = null) {
10914 const scrollMode = this._scrollMode,
10915 viewer = this.viewer;
10919 if (!this.pdfDocument || !pageNumber) {
10920 return;
10921 }
10923 if (this._currentScaleValue && isNaN(this._currentScaleValue)) {
10924 this._setScale(this._currentScaleValue, true);
10925 }
10927 this._setCurrentPageNumber(pageNumber, true);
10929 this.update();
10930 }
10932 get spreadMode() {
10933 return this._spreadMode;
10934 }
10936 set spreadMode(mode) {
10937 if (this._spreadMode === mode) {
10938 return;
10939 }
10941 if (!(0, _ui_utils.isValidSpreadMode)(mode)) {
10943 }
10945 this._spreadMode = mode;
10947 source: this,
10948 mode
10949 });
10951 this._updateSpreadMode(this._currentPageNumber);
10952 }
10954 _updateSpreadMode(pageNumber = null) {
10955 if (!this.pdfDocument) {
10956 return;
10957 }
10959 const viewer = this.viewer,
10960 pages = this._pages;
10963 if (this._spreadMode === _ui_utils.SpreadMode.NONE) {
10964 for (let i = 0, iMax = pages.length; i < iMax; ++i) {
10965 viewer.appendChild(pages[i].div);
10966 }
10967 } else {
10968 const parity = this._spreadMode - 1;
10969 let spread = null;
10971 for (let i = 0, iMax = pages.length; i < iMax; ++i) {
10972 if (spread === null) {
10975 viewer.appendChild(spread);
10976 } else if (i % 2 === parity) {
10977 spread = spread.cloneNode(false);
10978 viewer.appendChild(spread);
10979 }
10981 spread.appendChild(pages[i].div);
10982 }
10983 }
10985 if (!pageNumber) {
10986 return;
10987 }
10989 if (this._currentScaleValue && isNaN(this._currentScaleValue)) {
10990 this._setScale(this._currentScaleValue, true);
10991 }
10993 this._setCurrentPageNumber(pageNumber, true);
10995 this.update();
10996 }
10998 _getPageAdvance(currentPageNumber, previous = false) {
10999 if (this.isInPresentationMode) {
11000 return 1;
11001 }
11003 switch (this._scrollMode) {
11004 case _ui_utils.ScrollMode.WRAPPED:
11005 {
11006 const {
11007 views
11008 } = this._getVisiblePages(),
11009 pageLayout = new Map();
11011 for (const {
11012 id,
11013 y,
11014 percent,
11015 widthPercent
11016 } of views) {
11017 if (percent === 0 || widthPercent < 100) {
11018 continue;
11019 }
11021 let yArray = pageLayout.get(y);
11023 if (!yArray) {
11024 pageLayout.set(y, yArray || (yArray = []));
11025 }
11027 yArray.push(id);
11028 }
11030 for (const yArray of pageLayout.values()) {
11031 const currentIndex = yArray.indexOf(currentPageNumber);
11033 if (currentIndex === -1) {
11034 continue;
11035 }
11037 const numPages = yArray.length;
11039 if (numPages === 1) {
11040 break;
11041 }
11043 if (previous) {
11044 for (let i = currentIndex - 1, ii = 0; i >= ii; i--) {
11045 const currentId = yArray[i],
11046 expectedId = yArray[i + 1] - 1;
11048 if (currentId < expectedId) {
11049 return currentPageNumber - expectedId;
11050 }
11051 }
11052 } else {
11053 for (let i = currentIndex + 1, ii = numPages; i < ii; i++) {
11054 const currentId = yArray[i],
11055 expectedId = yArray[i - 1] + 1;
11057 if (currentId > expectedId) {
11058 return expectedId - currentPageNumber;
11059 }
11060 }
11061 }
11063 if (previous) {
11064 const firstId = yArray[0];
11066 if (firstId < currentPageNumber) {
11067 return currentPageNumber - firstId + 1;
11068 }
11069 } else {
11070 const lastId = yArray[numPages - 1];
11072 if (lastId > currentPageNumber) {
11073 return lastId - currentPageNumber + 1;
11074 }
11075 }
11077 break;
11078 }
11080 break;
11081 }
11083 case _ui_utils.ScrollMode.HORIZONTAL:
11084 {
11085 break;
11086 }
11088 case _ui_utils.ScrollMode.VERTICAL:
11089 {
11090 if (this._spreadMode === _ui_utils.SpreadMode.NONE) {
11091 break;
11092 }
11094 const parity = this._spreadMode - 1;
11096 if (previous && currentPageNumber % 2 !== parity) {
11097 break;
11098 } else if (!previous && currentPageNumber % 2 === parity) {
11099 break;
11100 }
11102 const {
11103 views
11104 } = this._getVisiblePages(),
11105 expectedId = previous ? currentPageNumber - 1 : currentPageNumber + 1;
11107 for (const {
11108 id,
11109 percent,
11110 widthPercent
11111 } of views) {
11112 if (id !== expectedId) {
11113 continue;
11114 }
11116 if (percent > 0 && widthPercent === 100) {
11117 return 2;
11118 }
11120 break;
11121 }
11123 break;
11124 }
11125 }
11127 return 1;
11128 }
11130 nextPage() {
11131 const currentPageNumber = this._currentPageNumber,
11132 pagesCount = this.pagesCount;
11134 if (currentPageNumber >= pagesCount) {
11135 return false;
11136 }
11138 const advance = this._getPageAdvance(currentPageNumber, false) || 1;
11139 this.currentPageNumber = Math.min(currentPageNumber + advance, pagesCount);
11140 return true;
11141 }
11143 previousPage() {
11144 const currentPageNumber = this._currentPageNumber;
11146 if (currentPageNumber <= 1) {
11147 return false;
11148 }
11150 const advance = this._getPageAdvance(currentPageNumber, true) || 1;
11151 this.currentPageNumber = Math.max(currentPageNumber - advance, 1);
11152 return true;
11153 }
11155 }
11157 exports.BaseViewer = BaseViewer;
11159 /***/ }),
11160 /* 29 */
11161 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
11166 value: true
11167 }));
11168 exports.DefaultAnnotationLayerFactory = exports.AnnotationLayerBuilder = void 0;
11170 var _pdfjsLib = __webpack_require__(5);
11172 var _l10n_utils = __webpack_require__(30);
11174 var _pdf_link_service = __webpack_require__(19);
11176 class AnnotationLayerBuilder {
11177 constructor({
11178 pageDiv,
11179 pdfPage,
11180 linkService,
11181 downloadManager,
11182 annotationStorage = null,
11184 renderInteractiveForms = true,
11185 l10n = _l10n_utils.NullL10n,
11186 enableScripting = false,
11187 hasJSActionsPromise = null,
11188 mouseState = null
11189 }) {
11190 this.pageDiv = pageDiv;
11191 this.pdfPage = pdfPage;
11192 this.linkService = linkService;
11193 this.downloadManager = downloadManager;
11194 this.imageResourcesPath = imageResourcesPath;
11195 this.renderInteractiveForms = renderInteractiveForms;
11196 this.l10n = l10n;
11197 this.annotationStorage = annotationStorage;
11198 this.enableScripting = enableScripting;
11199 this._hasJSActionsPromise = hasJSActionsPromise;
11200 this._mouseState = mouseState;
11201 this.div = null;
11202 this._cancelled = false;
11203 }
11206 return Promise.all([this.pdfPage.getAnnotations({
11207 intent
11208 }), this._hasJSActionsPromise]).then(([annotations, hasJSActions = false]) => {
11209 if (this._cancelled) {
11210 return;
11211 }
11213 if (annotations.length === 0) {
11214 return;
11215 }
11217 const parameters = {
11218 viewport: viewport.clone({
11219 dontFlip: true
11220 }),
11221 div: this.div,
11222 annotations,
11223 page: this.pdfPage,
11224 imageResourcesPath: this.imageResourcesPath,
11225 renderInteractiveForms: this.renderInteractiveForms,
11226 linkService: this.linkService,
11227 downloadManager: this.downloadManager,
11228 annotationStorage: this.annotationStorage,
11229 enableScripting: this.enableScripting,
11230 hasJSActions,
11231 mouseState: this._mouseState
11232 };
11234 if (this.div) {
11235 _pdfjsLib.AnnotationLayer.update(parameters);
11236 } else {
11239 this.pageDiv.appendChild(this.div);
11240 parameters.div = this.div;
11242 _pdfjsLib.AnnotationLayer.render(parameters);
11244 this.l10n.translate(this.div);
11245 }
11246 });
11247 }
11249 cancel() {
11250 this._cancelled = true;
11251 }
11253 hide() {
11254 if (!this.div) {
11255 return;
11256 }
11258 this.div.hidden = true;
11259 }
11261 }
11263 exports.AnnotationLayerBuilder = AnnotationLayerBuilder;
11265 class DefaultAnnotationLayerFactory {
11266 createAnnotationLayerBuilder(pageDiv, pdfPage, annotationStorage = null, imageResourcesPath = "", renderInteractiveForms = true, l10n = _l10n_utils.NullL10n, enableScripting = false, hasJSActionsPromise = null, mouseState = null) {
11267 return new AnnotationLayerBuilder({
11268 pageDiv,
11269 pdfPage,
11270 imageResourcesPath,
11271 renderInteractiveForms,
11272 linkService: new _pdf_link_service.SimpleLinkService(),
11273 l10n,
11274 annotationStorage,
11275 enableScripting,
11276 hasJSActionsPromise,
11277 mouseState
11278 });
11279 }
11281 }
11283 exports.DefaultAnnotationLayerFactory = DefaultAnnotationLayerFactory;
11285 /***/ }),
11286 /* 30 */
11287 /***/ ((__unused_webpack_module, exports) => {
11292 value: true
11293 }));
11294 exports.fixupLangCode = fixupLangCode;
11295 exports.getL10nFallback = getL10nFallback;
11296 exports.NullL10n = void 0;
11297 const DEFAULT_L10N_STRINGS = {
11311 document_properties_page_size_dimension_string: "{{width}} × {{height}} {{unit}} ({{orientation}})",
11312 document_properties_page_size_dimension_name_string: "{{width}} × {{height}} {{unit}} ({{name}}, {{orientation}})",
11317 "toggle_sidebar_notification2.title": "Toggle Sidebar (document contains outline/attachments/layers)",
11348 };
11350 function getL10nFallback(key, args) {
11351 switch (key) {
11354 break;
11358 break;
11359 }
11362 }
11364 const PARTIAL_LANG_CODES = {
11379 };
11381 function fixupLangCode(langCode) {
11382 return PARTIAL_LANG_CODES[langCode?.toLowerCase()] || langCode;
11383 }
11385 function formatL10nValue(text, args) {
11386 if (!args) {
11387 return text;
11388 }
11390 return text.replace(/\{\{\s*(\w+)\s*\}\}/g, (all, name) => {
11392 });
11393 }
11395 const NullL10n = {
11396 async getLanguage() {
11398 },
11400 async getDirection() {
11402 },
11404 async get(key, args = null, fallback = getL10nFallback(key, args)) {
11405 return formatL10nValue(fallback, args);
11406 },
11408 async translate(element) {}
11410 };
11411 exports.NullL10n = NullL10n;
11413 /***/ }),
11414 /* 31 */
11415 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
11420 value: true
11421 }));
11422 exports.PDFPageView = void 0;
11424 var _ui_utils = __webpack_require__(4);
11426 var _pdfjsLib = __webpack_require__(5);
11428 var _l10n_utils = __webpack_require__(30);
11430 var _pdf_rendering_queue = __webpack_require__(8);
11432 var _viewer_compatibility = __webpack_require__(2);
11434 const MAX_CANVAS_PIXELS = _viewer_compatibility.viewerCompatibilityParams.maxCanvasPixels || 16777216;
11436 class PDFPageView {
11437 constructor(options) {
11438 const container = options.container;
11439 const defaultViewport = options.defaultViewport;
11440 this.id = options.id;
11442 this.pdfPage = null;
11443 this.pageLabel = null;
11444 this.rotation = 0;
11445 this.scale = options.scale || _ui_utils.DEFAULT_SCALE;
11446 this.viewport = defaultViewport;
11447 this.pdfPageRotate = defaultViewport.rotation;
11448 this._optionalContentConfigPromise = options.optionalContentConfigPromise || null;
11449 this.hasRestrictedScaling = false;
11450 this.textLayerMode = Number.isInteger(options.textLayerMode) ? options.textLayerMode : _ui_utils.TextLayerMode.ENABLE;
11452 this.renderInteractiveForms = options.renderInteractiveForms !== false;
11453 this.useOnlyCssZoom = options.useOnlyCssZoom || false;
11454 this.maxCanvasPixels = options.maxCanvasPixels || MAX_CANVAS_PIXELS;
11455 this.eventBus = options.eventBus;
11456 this.renderingQueue = options.renderingQueue;
11457 this.textLayerFactory = options.textLayerFactory;
11458 this.annotationLayerFactory = options.annotationLayerFactory;
11459 this.xfaLayerFactory = options.xfaLayerFactory;
11460 this.structTreeLayerFactory = options.structTreeLayerFactory;
11461 this.renderer = options.renderer || _ui_utils.RendererType.CANVAS;
11462 this.l10n = options.l10n || _l10n_utils.NullL10n;
11463 this.paintTask = null;
11464 this.paintedViewportMap = new WeakMap();
11465 this.renderingState = _pdf_rendering_queue.RenderingStates.INITIAL;
11466 this.resume = null;
11467 this._renderError = null;
11468 this.annotationLayer = null;
11469 this.textLayer = null;
11470 this.zoomLayer = null;
11471 this.xfaLayer = null;
11472 this.structTreeLayer = null;
11480 page: this.id
11481 }).then(msg => {
11483 });
11484 this.div = div;
11485 container.appendChild(div);
11486 }
11488 setPdfPage(pdfPage) {
11489 this.pdfPage = pdfPage;
11490 this.pdfPageRotate = pdfPage.rotate;
11491 const totalRotation = (this.rotation + this.pdfPageRotate) % 360;
11492 this.viewport = pdfPage.getViewport({
11493 scale: this.scale * _ui_utils.CSS_UNITS,
11494 rotation: totalRotation
11495 });
11496 this.reset();
11497 }
11499 destroy() {
11500 this.reset();
11502 if (this.pdfPage) {
11503 this.pdfPage.cleanup();
11504 }
11505 }
11507 async _renderAnnotationLayer() {
11508 let error = null;
11510 try {
11512 } catch (ex) {
11513 error = ex;
11514 } finally {
11516 source: this,
11517 pageNumber: this.id,
11518 error
11519 });
11520 }
11521 }
11523 async _renderXfaLayer() {
11524 let error = null;
11526 try {
11528 } catch (ex) {
11529 error = ex;
11530 } finally {
11532 source: this,
11533 pageNumber: this.id,
11534 error
11535 });
11536 }
11537 }
11539 _resetZoomLayer(removeFromDOM = false) {
11540 if (!this.zoomLayer) {
11541 return;
11542 }
11544 const zoomLayerCanvas = this.zoomLayer.firstChild;
11545 this.paintedViewportMap.delete(zoomLayerCanvas);
11546 zoomLayerCanvas.width = 0;
11547 zoomLayerCanvas.height = 0;
11549 if (removeFromDOM) {
11550 this.zoomLayer.remove();
11551 }
11553 this.zoomLayer = null;
11554 }
11556 reset({
11557 keepZoomLayer = false,
11558 keepAnnotationLayer = false,
11559 keepXfaLayer = false
11560 } = {}) {
11561 this.cancelRendering({
11562 keepAnnotationLayer,
11563 keepXfaLayer
11564 });
11565 this.renderingState = _pdf_rendering_queue.RenderingStates.INITIAL;
11566 const div = this.div;
11569 const childNodes = div.childNodes,
11570 zoomLayerNode = keepZoomLayer && this.zoomLayer || null,
11571 annotationLayerNode = keepAnnotationLayer && this.annotationLayer?.div || null,
11572 xfaLayerNode = keepXfaLayer && this.xfaLayer?.div || null;
11574 for (let i = childNodes.length - 1; i >= 0; i--) {
11575 const node = childNodes[i];
11577 switch (node) {
11578 case zoomLayerNode:
11579 case annotationLayerNode:
11580 case xfaLayerNode:
11581 continue;
11582 }
11584 div.removeChild(node);
11585 }
11589 if (annotationLayerNode) {
11590 this.annotationLayer.hide();
11591 }
11593 if (xfaLayerNode) {
11594 this.xfaLayer.hide();
11595 }
11597 if (!zoomLayerNode) {
11598 if (this.canvas) {
11599 this.paintedViewportMap.delete(this.canvas);
11600 this.canvas.width = 0;
11601 this.canvas.height = 0;
11602 delete this.canvas;
11603 }
11605 this._resetZoomLayer();
11606 }
11608 if (this.svg) {
11609 this.paintedViewportMap.delete(this.svg);
11610 delete this.svg;
11611 }
11618 });
11619 div.appendChild(this.loadingIconDiv);
11620 }
11622 update(scale, rotation, optionalContentConfigPromise = null) {
11623 this.scale = scale || this.scale;
11626 this.rotation = rotation;
11627 }
11629 if (optionalContentConfigPromise instanceof Promise) {
11630 this._optionalContentConfigPromise = optionalContentConfigPromise;
11631 }
11633 const totalRotation = (this.rotation + this.pdfPageRotate) % 360;
11634 this.viewport = this.viewport.clone({
11635 scale: this.scale * _ui_utils.CSS_UNITS,
11636 rotation: totalRotation
11637 });
11639 if (this.svg) {
11640 this.cssTransform({
11641 target: this.svg,
11642 redrawAnnotationLayer: true,
11643 redrawXfaLayer: true
11644 });
11646 source: this,
11647 pageNumber: this.id,
11648 cssTransform: true,
11649 timestamp: performance.now(),
11650 error: this._renderError
11651 });
11652 return;
11653 }
11655 let isScalingRestricted = false;
11657 if (this.canvas && this.maxCanvasPixels > 0) {
11658 const outputScale = this.outputScale;
11660 if ((Math.floor(this.viewport.width) * outputScale.sx | 0) * (Math.floor(this.viewport.height) * outputScale.sy | 0) > this.maxCanvasPixels) {
11661 isScalingRestricted = true;
11662 }
11663 }
11665 if (this.canvas) {
11666 if (this.useOnlyCssZoom || this.hasRestrictedScaling && isScalingRestricted) {
11667 this.cssTransform({
11668 target: this.canvas,
11669 redrawAnnotationLayer: true,
11670 redrawXfaLayer: true
11671 });
11673 source: this,
11674 pageNumber: this.id,
11675 cssTransform: true,
11676 timestamp: performance.now(),
11677 error: this._renderError
11678 });
11679 return;
11680 }
11682 if (!this.zoomLayer && !this.canvas.hidden) {
11683 this.zoomLayer = this.canvas.parentNode;
11685 }
11686 }
11688 if (this.zoomLayer) {
11689 this.cssTransform({
11690 target: this.zoomLayer.firstChild
11691 });
11692 }
11694 this.reset({
11695 keepZoomLayer: true,
11696 keepAnnotationLayer: true,
11697 keepXfaLayer: true
11698 });
11699 }
11701 cancelRendering({
11702 keepAnnotationLayer = false,
11703 keepXfaLayer = false
11704 } = {}) {
11705 if (this.paintTask) {
11706 this.paintTask.cancel();
11707 this.paintTask = null;
11708 }
11710 this.resume = null;
11712 if (this.textLayer) {
11713 this.textLayer.cancel();
11714 this.textLayer = null;
11715 }
11717 if (this.annotationLayer && (!keepAnnotationLayer || !this.annotationLayer.div)) {
11718 this.annotationLayer.cancel();
11719 this.annotationLayer = null;
11720 }
11722 if (this.xfaLayer && (!keepXfaLayer || !this.xfaLayer.div)) {
11723 this.xfaLayer.cancel();
11724 this.xfaLayer = null;
11725 }
11727 if (this._onTextLayerRendered) {
11730 this._onTextLayerRendered = null;
11731 }
11732 }
11734 cssTransform({
11735 target,
11736 redrawAnnotationLayer = false,
11737 redrawXfaLayer = false
11738 }) {
11739 const width = this.viewport.width;
11740 const height = this.viewport.height;
11741 const div = this.div;
11742 target.style.width = target.parentNode.style.width = div.style.width = Math.floor(width) + "px";
11743 target.style.height = target.parentNode.style.height = div.style.height = Math.floor(height) + "px";
11744 const relativeRotation = this.viewport.rotation - this.paintedViewportMap.get(target).rotation;
11745 const absRotation = Math.abs(relativeRotation);
11746 let scaleX = 1,
11747 scaleY = 1;
11749 if (absRotation === 90 || absRotation === 270) {
11750 scaleX = height / width;
11751 scaleY = width / height;
11752 }
11756 if (this.textLayer) {
11757 const textLayerViewport = this.textLayer.viewport;
11758 const textRelativeRotation = this.viewport.rotation - textLayerViewport.rotation;
11759 const textAbsRotation = Math.abs(textRelativeRotation);
11760 let scale = width / textLayerViewport.width;
11762 if (textAbsRotation === 90 || textAbsRotation === 270) {
11763 scale = width / textLayerViewport.height;
11764 }
11766 const textLayerDiv = this.textLayer.textLayerDiv;
11767 let transX, transY;
11769 switch (textAbsRotation) {
11770 case 0:
11771 transX = transY = 0;
11772 break;
11774 case 90:
11775 transX = 0;
11777 break;
11779 case 180:
11782 break;
11784 case 270:
11786 transY = 0;
11787 break;
11789 default:
11791 break;
11792 }
11794 textLayerDiv.style.transform = `rotate(${textAbsRotation}deg) ` + `scale(${scale}) ` + `translate(${transX}, ${transY})`;
11796 }
11798 if (redrawAnnotationLayer && this.annotationLayer) {
11799 this._renderAnnotationLayer();
11800 }
11802 if (redrawXfaLayer && this.xfaLayer) {
11803 this._renderXfaLayer();
11804 }
11805 }
11807 get width() {
11808 return this.viewport.width;
11809 }
11811 get height() {
11812 return this.viewport.height;
11813 }
11815 getPagePoint(x, y) {
11816 return this.viewport.convertToPdfPoint(x, y);
11817 }
11819 draw() {
11820 if (this.renderingState !== _pdf_rendering_queue.RenderingStates.INITIAL) {
11822 this.reset();
11823 }
11825 const {
11826 div,
11827 pdfPage
11828 } = this;
11830 if (!pdfPage) {
11831 this.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED;
11833 if (this.loadingIconDiv) {
11834 div.removeChild(this.loadingIconDiv);
11835 delete this.loadingIconDiv;
11836 }
11839 }
11841 this.renderingState = _pdf_rendering_queue.RenderingStates.RUNNING;
11843 canvasWrapper.style.width = div.style.width;
11844 canvasWrapper.style.height = div.style.height;
11847 if (this.annotationLayer?.div) {
11848 div.insertBefore(canvasWrapper, this.annotationLayer.div);
11849 } else {
11850 div.appendChild(canvasWrapper);
11851 }
11853 let textLayer = null;
11855 if (this.textLayerMode !== _ui_utils.TextLayerMode.DISABLE && this.textLayerFactory) {
11858 textLayerDiv.style.width = canvasWrapper.style.width;
11859 textLayerDiv.style.height = canvasWrapper.style.height;
11861 if (this.annotationLayer?.div) {
11862 div.insertBefore(textLayerDiv, this.annotationLayer.div);
11863 } else {
11864 div.appendChild(textLayerDiv);
11865 }
11867 textLayer = this.textLayerFactory.createTextLayerBuilder(textLayerDiv, this.id - 1, this.viewport, this.textLayerMode === _ui_utils.TextLayerMode.ENABLE_ENHANCE, this.eventBus);
11868 }
11870 this.textLayer = textLayer;
11872 if (this.xfaLayer?.div) {
11873 div.appendChild(this.xfaLayer.div);
11874 }
11876 let renderContinueCallback = null;
11878 if (this.renderingQueue) {
11879 renderContinueCallback = cont => {
11880 if (!this.renderingQueue.isHighestPriority(this)) {
11881 this.renderingState = _pdf_rendering_queue.RenderingStates.PAUSED;
11883 this.resume = () => {
11884 this.renderingState = _pdf_rendering_queue.RenderingStates.RUNNING;
11885 cont();
11886 };
11888 return;
11889 }
11891 cont();
11892 };
11893 }
11895 const finishPaintTask = async (error = null) => {
11896 if (paintTask === this.paintTask) {
11897 this.paintTask = null;
11898 }
11900 if (error instanceof _pdfjsLib.RenderingCancelledException) {
11901 this._renderError = null;
11902 return;
11903 }
11905 this._renderError = error;
11906 this.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED;
11908 if (this.loadingIconDiv) {
11909 div.removeChild(this.loadingIconDiv);
11910 delete this.loadingIconDiv;
11911 }
11913 this._resetZoomLayer(true);
11916 source: this,
11917 pageNumber: this.id,
11918 cssTransform: false,
11919 timestamp: performance.now(),
11920 error: this._renderError
11921 });
11923 if (error) {
11924 throw error;
11925 }
11926 };
11928 const paintTask = this.renderer === _ui_utils.RendererType.SVG ? this.paintOnSvg(canvasWrapper) : this.paintOnCanvas(canvasWrapper);
11929 paintTask.onRenderContinue = renderContinueCallback;
11930 this.paintTask = paintTask;
11931 const resultPromise = paintTask.promise.then(() => {
11932 return finishPaintTask(null).then(() => {
11933 if (textLayer) {
11934 const readableStream = pdfPage.streamTextContent({
11935 normalizeWhitespace: true,
11936 includeMarkedContent: true
11937 });
11938 textLayer.setTextContentStream(readableStream);
11939 textLayer.render();
11940 }
11941 });
11942 }, function (reason) {
11943 return finishPaintTask(reason);
11944 });
11946 if (this.annotationLayerFactory) {
11947 if (!this.annotationLayer) {
11948 this.annotationLayer = this.annotationLayerFactory.createAnnotationLayerBuilder(div, pdfPage, null, this.imageResourcesPath, this.renderInteractiveForms, this.l10n, null, null, null);
11949 }
11951 this._renderAnnotationLayer();
11952 }
11954 if (this.xfaLayerFactory) {
11955 if (!this.xfaLayer) {
11956 this.xfaLayer = this.xfaLayerFactory.createXfaLayerBuilder(div, pdfPage, null);
11957 }
11959 this._renderXfaLayer();
11960 }
11962 if (this.structTreeLayerFactory && this.textLayer && this.canvas) {
11963 this._onTextLayerRendered = event => {
11964 if (event.pageNumber !== this.id) {
11965 return;
11966 }
11970 this._onTextLayerRendered = null;
11972 if (!this.canvas) {
11973 return;
11974 }
11976 this.pdfPage.getStructTree().then(tree => {
11977 if (!tree) {
11978 return;
11979 }
11981 if (!this.canvas) {
11982 return;
11983 }
11985 const treeDom = this.structTreeLayer.render(tree);
11987 this.canvas.appendChild(treeDom);
11988 });
11989 };
11993 this.structTreeLayer = this.structTreeLayerFactory.createStructTreeLayerBuilder(pdfPage);
11994 }
11998 source: this,
11999 pageNumber: this.id
12000 });
12001 return resultPromise;
12002 }
12004 paintOnCanvas(canvasWrapper) {
12005 const renderCapability = (0, _pdfjsLib.createPromiseCapability)();
12006 const result = {
12007 promise: renderCapability.promise,
12009 onRenderContinue(cont) {
12010 cont();
12011 },
12013 cancel() {
12014 renderTask.cancel();
12015 }
12017 };
12018 const viewport = this.viewport;
12020 canvas.hidden = true;
12021 let isCanvasHidden = true;
12023 const showCanvas = function () {
12024 if (isCanvasHidden) {
12025 canvas.hidden = false;
12026 isCanvasHidden = false;
12027 }
12028 };
12030 canvasWrapper.appendChild(canvas);
12031 this.canvas = canvas;
12032 canvas.mozOpaque = true;
12034 alpha: false
12035 });
12036 const outputScale = (0, _ui_utils.getOutputScale)(ctx);
12037 this.outputScale = outputScale;
12039 if (this.useOnlyCssZoom) {
12040 const actualSizeViewport = viewport.clone({
12041 scale: _ui_utils.CSS_UNITS
12042 });
12043 outputScale.sx *= actualSizeViewport.width / viewport.width;
12044 outputScale.sy *= actualSizeViewport.height / viewport.height;
12045 outputScale.scaled = true;
12046 }
12048 if (this.maxCanvasPixels > 0) {
12049 const pixelsInViewport = viewport.width * viewport.height;
12050 const maxScale = Math.sqrt(this.maxCanvasPixels / pixelsInViewport);
12052 if (outputScale.sx > maxScale || outputScale.sy > maxScale) {
12053 outputScale.sx = maxScale;
12054 outputScale.sy = maxScale;
12055 outputScale.scaled = true;
12056 this.hasRestrictedScaling = true;
12057 } else {
12058 this.hasRestrictedScaling = false;
12059 }
12060 }
12062 const sfx = (0, _ui_utils.approximateFraction)(outputScale.sx);
12063 const sfy = (0, _ui_utils.approximateFraction)(outputScale.sy);
12064 canvas.width = (0, _ui_utils.roundToDivide)(viewport.width * outputScale.sx, sfx[0]);
12065 canvas.height = (0, _ui_utils.roundToDivide)(viewport.height * outputScale.sy, sfy[0]);
12068 this.paintedViewportMap.set(canvas, viewport);
12069 const transform = !outputScale.scaled ? null : [outputScale.sx, 0, 0, outputScale.sy, 0, 0];
12070 const renderContext = {
12071 canvasContext: ctx,
12072 transform,
12073 viewport: this.viewport,
12074 renderInteractiveForms: this.renderInteractiveForms,
12075 optionalContentConfigPromise: this._optionalContentConfigPromise
12076 };
12077 const renderTask = this.pdfPage.render(renderContext);
12079 renderTask.onContinue = function (cont) {
12080 showCanvas();
12082 if (result.onRenderContinue) {
12083 result.onRenderContinue(cont);
12084 } else {
12085 cont();
12086 }
12087 };
12089 renderTask.promise.then(function () {
12090 showCanvas();
12091 renderCapability.resolve(undefined);
12092 }, function (error) {
12093 showCanvas();
12094 renderCapability.reject(error);
12095 });
12096 return result;
12097 }
12099 paintOnSvg(wrapper) {
12100 let cancelled = false;
12102 const ensureNotCancelled = () => {
12103 if (cancelled) {
12104 throw new _pdfjsLib.RenderingCancelledException(`Rendering cancelled, page ${this.id}`, "svg");
12105 }
12106 };
12108 const pdfPage = this.pdfPage;
12109 const actualSizeViewport = this.viewport.clone({
12110 scale: _ui_utils.CSS_UNITS
12111 });
12112 const promise = pdfPage.getOperatorList().then(opList => {
12113 ensureNotCancelled();
12114 const svgGfx = new _pdfjsLib.SVGGraphics(pdfPage.commonObjs, pdfPage.objs, _viewer_compatibility.viewerCompatibilityParams.disableCreateObjectURL);
12115 return svgGfx.getSVG(opList, actualSizeViewport).then(svg => {
12116 ensureNotCancelled();
12117 this.svg = svg;
12118 this.paintedViewportMap.set(svg, actualSizeViewport);
12119 svg.style.width = wrapper.style.width;
12120 svg.style.height = wrapper.style.height;
12121 this.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED;
12122 wrapper.appendChild(svg);
12123 });
12124 });
12125 return {
12126 promise,
12128 onRenderContinue(cont) {
12129 cont();
12130 },
12132 cancel() {
12133 cancelled = true;
12134 }
12136 };
12137 }
12139 setPageLabel(label) {
12142 if (this.pageLabel !== null) {
12144 } else {
12146 }
12147 }
12149 }
12151 exports.PDFPageView = PDFPageView;
12153 /***/ }),
12154 /* 32 */
12155 /***/ ((__unused_webpack_module, exports) => {
12160 value: true
12161 }));
12162 exports.StructTreeLayerBuilder = exports.DefaultStructTreeLayerFactory = void 0;
12163 const PDF_ROLE_TO_HTML_ROLE = {
12164 Document: null,
12165 DocumentFragment: null,
12171 P: null,
12173 Title: null,
12176 Lbl: null,
12177 Span: null,
12178 Em: null,
12179 Strong: null,
12183 Ruby: null,
12184 RB: null,
12185 RT: null,
12186 RP: null,
12187 Warichu: null,
12188 WT: null,
12189 WP: null,
12192 LBody: null,
12198 TBody: null,
12199 TFoot: null,
12200 Caption: null,
12202 Formula: null,
12203 Artifact: null
12204 };
12205 const HEADING_PATTERN = /^H(\d+)$/;
12207 class StructTreeLayerBuilder {
12208 constructor({
12209 pdfPage
12210 }) {
12211 this.pdfPage = pdfPage;
12212 }
12214 render(structTree) {
12215 return this._walk(structTree);
12216 }
12218 _setAttributes(structElement, htmlElement) {
12219 if (structElement.alt !== undefined) {
12221 }
12223 if (structElement.id !== undefined) {
12225 }
12226 }
12228 _walk(node) {
12229 if (!node) {
12230 return null;
12231 }
12236 const {
12237 role
12238 } = node;
12239 const match = role.match(HEADING_PATTERN);
12241 if (match) {
12244 } else if (PDF_ROLE_TO_HTML_ROLE[role]) {
12246 }
12247 }
12249 this._setAttributes(node, element);
12251 if (node.children) {
12253 this._setAttributes(node.children[0], element);
12254 } else {
12255 for (const kid of node.children) {
12256 element.appendChild(this._walk(kid));
12257 }
12258 }
12259 }
12261 return element;
12262 }
12264 }
12266 exports.StructTreeLayerBuilder = StructTreeLayerBuilder;
12268 class DefaultStructTreeLayerFactory {
12269 createStructTreeLayerBuilder(pdfPage) {
12270 return new StructTreeLayerBuilder({
12271 pdfPage
12272 });
12273 }
12275 }
12277 exports.DefaultStructTreeLayerFactory = DefaultStructTreeLayerFactory;
12279 /***/ }),
12280 /* 33 */
12281 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
12286 value: true
12287 }));
12288 exports.TextLayerBuilder = exports.DefaultTextLayerFactory = void 0;
12290 var _pdfjsLib = __webpack_require__(5);
12292 const EXPAND_DIVS_TIMEOUT = 300;
12294 class TextLayerBuilder {
12295 constructor({
12296 textLayerDiv,
12297 eventBus,
12298 pageIndex,
12299 viewport,
12300 findController = null,
12301 enhanceTextSelection = false
12302 }) {
12303 this.textLayerDiv = textLayerDiv;
12304 this.eventBus = eventBus;
12305 this.textContent = null;
12306 this.textContentItemsStr = [];
12307 this.textContentStream = null;
12308 this.renderingDone = false;
12309 this.pageIdx = pageIndex;
12310 this.pageNumber = this.pageIdx + 1;
12311 this.matches = [];
12312 this.viewport = viewport;
12313 this.textDivs = [];
12314 this.findController = findController;
12315 this.textLayerRenderTask = null;
12316 this.enhanceTextSelection = enhanceTextSelection;
12317 this._onUpdateTextLayerMatches = null;
12319 this._bindMouse();
12320 }
12322 _finishRendering() {
12323 this.renderingDone = true;
12325 if (!this.enhanceTextSelection) {
12328 this.textLayerDiv.appendChild(endOfContent);
12329 }
12332 source: this,
12333 pageNumber: this.pageNumber,
12334 numTextDivs: this.textDivs.length
12335 });
12336 }
12338 render(timeout = 0) {
12339 if (!(this.textContent || this.textContentStream) || this.renderingDone) {
12340 return;
12341 }
12343 this.cancel();
12344 this.textDivs = [];
12345 const textLayerFrag = document.createDocumentFragment();
12346 this.textLayerRenderTask = (0, _pdfjsLib.renderTextLayer)({
12347 textContent: this.textContent,
12348 textContentStream: this.textContentStream,
12349 container: textLayerFrag,
12350 viewport: this.viewport,
12351 textDivs: this.textDivs,
12352 textContentItemsStr: this.textContentItemsStr,
12353 timeout,
12354 enhanceTextSelection: this.enhanceTextSelection
12355 });
12356 this.textLayerRenderTask.promise.then(() => {
12357 this.textLayerDiv.appendChild(textLayerFrag);
12359 this._finishRendering();
12361 this._updateMatches();
12362 }, function (reason) {});
12364 if (!this._onUpdateTextLayerMatches) {
12365 this._onUpdateTextLayerMatches = evt => {
12366 if (evt.pageIndex === this.pageIdx || evt.pageIndex === -1) {
12367 this._updateMatches();
12368 }
12369 };
12372 }
12373 }
12375 cancel() {
12376 if (this.textLayerRenderTask) {
12377 this.textLayerRenderTask.cancel();
12378 this.textLayerRenderTask = null;
12379 }
12381 if (this._onUpdateTextLayerMatches) {
12384 this._onUpdateTextLayerMatches = null;
12385 }
12386 }
12388 setTextContentStream(readableStream) {
12389 this.cancel();
12390 this.textContentStream = readableStream;
12391 }
12393 setTextContent(textContent) {
12394 this.cancel();
12395 this.textContent = textContent;
12396 }
12398 _convertMatches(matches, matchesLength) {
12399 if (!matches) {
12400 return [];
12401 }
12403 const {
12404 textContentItemsStr
12405 } = this;
12406 let i = 0,
12407 iIndex = 0;
12408 const end = textContentItemsStr.length - 1;
12409 const result = [];
12411 for (let m = 0, mm = matches.length; m < mm; m++) {
12412 let matchIdx = matches[m];
12414 while (i !== end && matchIdx >= iIndex + textContentItemsStr[i].length) {
12415 iIndex += textContentItemsStr[i].length;
12416 i++;
12417 }
12419 if (i === textContentItemsStr.length) {
12421 }
12423 const match = {
12424 begin: {
12425 divIdx: i,
12426 offset: matchIdx - iIndex
12427 }
12428 };
12429 matchIdx += matchesLength[m];
12431 while (i !== end && matchIdx > iIndex + textContentItemsStr[i].length) {
12432 iIndex += textContentItemsStr[i].length;
12433 i++;
12434 }
12436 match.end = {
12437 divIdx: i,
12438 offset: matchIdx - iIndex
12439 };
12440 result.push(match);
12441 }
12443 return result;
12444 }
12446 _renderMatches(matches) {
12447 if (matches.length === 0) {
12448 return;
12449 }
12451 const {
12452 findController,
12453 pageIdx,
12454 textContentItemsStr,
12455 textDivs
12456 } = this;
12457 const isSelectedPage = pageIdx === findController.selected.pageIdx;
12458 const selectedMatchIdx = findController.selected.matchIdx;
12459 const highlightAll = findController.state.highlightAll;
12460 let prevEnd = null;
12461 const infinity = {
12462 divIdx: -1,
12463 offset: undefined
12464 };
12466 function beginText(begin, className) {
12467 const divIdx = begin.divIdx;
12469 return appendTextToDiv(divIdx, 0, begin.offset, className);
12470 }
12472 function appendTextToDiv(divIdx, fromOffset, toOffset, className) {
12473 const div = textDivs[divIdx];
12474 const content = textContentItemsStr[divIdx].substring(fromOffset, toOffset);
12475 const node = document.createTextNode(content);
12477 if (className) {
12480 span.appendChild(node);
12481 div.appendChild(span);
12483 }
12485 div.appendChild(node);
12486 return 0;
12487 }
12489 let i0 = selectedMatchIdx,
12490 i1 = i0 + 1;
12492 if (highlightAll) {
12493 i0 = 0;
12494 i1 = matches.length;
12495 } else if (!isSelectedPage) {
12496 return;
12497 }
12499 for (let i = i0; i < i1; i++) {
12500 const match = matches[i];
12501 const begin = match.begin;
12502 const end = match.end;
12503 const isSelected = isSelectedPage && i === selectedMatchIdx;
12505 let selectedLeft = 0;
12507 if (!prevEnd || begin.divIdx !== prevEnd.divIdx) {
12508 if (prevEnd !== null) {
12509 appendTextToDiv(prevEnd.divIdx, prevEnd.offset, infinity.offset);
12510 }
12512 beginText(begin);
12513 } else {
12514 appendTextToDiv(prevEnd.divIdx, prevEnd.offset, begin.offset);
12515 }
12517 if (begin.divIdx === end.divIdx) {
12518 selectedLeft = appendTextToDiv(begin.divIdx, begin.offset, end.offset, "highlight" + highlightSuffix);
12519 } else {
12520 selectedLeft = appendTextToDiv(begin.divIdx, begin.offset, infinity.offset, "highlight begin" + highlightSuffix);
12522 for (let n0 = begin.divIdx + 1, n1 = end.divIdx; n0 < n1; n0++) {
12524 }
12527 }
12529 prevEnd = end;
12531 if (isSelected) {
12532 findController.scrollMatchIntoView({
12533 element: textDivs[begin.divIdx],
12534 selectedLeft,
12535 pageIndex: pageIdx,
12536 matchIndex: selectedMatchIdx
12537 });
12538 }
12539 }
12541 if (prevEnd) {
12542 appendTextToDiv(prevEnd.divIdx, prevEnd.offset, infinity.offset);
12543 }
12544 }
12546 _updateMatches() {
12547 if (!this.renderingDone) {
12548 return;
12549 }
12551 const {
12552 findController,
12553 matches,
12554 pageIdx,
12555 textContentItemsStr,
12556 textDivs
12557 } = this;
12558 let clearedUntilDivIdx = -1;
12560 for (let i = 0, ii = matches.length; i < ii; i++) {
12561 const match = matches[i];
12562 const begin = Math.max(clearedUntilDivIdx, match.begin.divIdx);
12564 for (let n = begin, end = match.end.divIdx; n <= end; n++) {
12565 const div = textDivs[n];
12566 div.textContent = textContentItemsStr[n];
12568 }
12570 clearedUntilDivIdx = match.end.divIdx + 1;
12571 }
12573 if (!findController?.highlightMatches) {
12574 return;
12575 }
12577 const pageMatches = findController.pageMatches[pageIdx] || null;
12578 const pageMatchesLength = findController.pageMatchesLength[pageIdx] || null;
12579 this.matches = this._convertMatches(pageMatches, pageMatchesLength);
12581 this._renderMatches(this.matches);
12582 }
12584 _bindMouse() {
12585 const div = this.textLayerDiv;
12586 let expandDivsTimer = null;
12588 if (this.enhanceTextSelection && this.textLayerRenderTask) {
12589 this.textLayerRenderTask.expandTextDivs(true);
12591 if (expandDivsTimer) {
12592 clearTimeout(expandDivsTimer);
12593 expandDivsTimer = null;
12594 }
12596 return;
12597 }
12601 if (!end) {
12602 return;
12603 }
12605 let adjustTop = evt.target !== div;
12606 adjustTop = adjustTop && window.getComputedStyle(end).getPropertyValue("-moz-user-select") !== "none";
12608 if (adjustTop) {
12609 const divBounds = div.getBoundingClientRect();
12610 const r = Math.max(0, (evt.pageY - divBounds.top) / divBounds.height);
12612 }
12615 });
12617 if (this.enhanceTextSelection && this.textLayerRenderTask) {
12618 expandDivsTimer = setTimeout(() => {
12619 if (this.textLayerRenderTask) {
12620 this.textLayerRenderTask.expandTextDivs(false);
12621 }
12623 expandDivsTimer = null;
12624 }, EXPAND_DIVS_TIMEOUT);
12625 return;
12626 }
12630 if (!end) {
12631 return;
12632 }
12636 });
12637 }
12639 }
12641 exports.TextLayerBuilder = TextLayerBuilder;
12643 class DefaultTextLayerFactory {
12644 createTextLayerBuilder(textLayerDiv, pageIndex, viewport, enhanceTextSelection = false, eventBus) {
12645 return new TextLayerBuilder({
12646 textLayerDiv,
12647 pageIndex,
12648 viewport,
12649 enhanceTextSelection,
12650 eventBus
12651 });
12652 }
12654 }
12656 exports.DefaultTextLayerFactory = DefaultTextLayerFactory;
12658 /***/ }),
12659 /* 34 */
12660 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
12665 value: true
12666 }));
12667 exports.XfaLayerBuilder = exports.DefaultXfaLayerFactory = void 0;
12669 var _pdfjsLib = __webpack_require__(5);
12671 class XfaLayerBuilder {
12672 constructor({
12673 pageDiv,
12674 pdfPage,
12675 xfaHtml,
12676 annotationStorage
12677 }) {
12678 this.pageDiv = pageDiv;
12679 this.pdfPage = pdfPage;
12680 this.xfaHtml = xfaHtml;
12681 this.annotationStorage = annotationStorage;
12682 this.div = null;
12683 this._cancelled = false;
12684 }
12688 const parameters = {
12689 viewport: viewport.clone({
12690 dontFlip: true
12691 }),
12692 div: this.div,
12693 xfa: this.xfaHtml,
12694 page: null,
12695 annotationStorage: this.annotationStorage,
12696 intent
12697 };
12699 this.pageDiv.appendChild(div);
12700 parameters.div = div;
12702 _pdfjsLib.XfaLayer.render(parameters);
12704 return Promise.resolve();
12705 }
12707 return this.pdfPage.getXfa().then(xfa => {
12708 if (this._cancelled) {
12709 return;
12710 }
12712 const parameters = {
12713 viewport: viewport.clone({
12714 dontFlip: true
12715 }),
12716 div: this.div,
12717 xfa,
12718 page: this.pdfPage,
12719 annotationStorage: this.annotationStorage,
12720 intent
12721 };
12723 if (this.div) {
12724 _pdfjsLib.XfaLayer.update(parameters);
12725 } else {
12727 this.pageDiv.appendChild(this.div);
12728 parameters.div = this.div;
12730 _pdfjsLib.XfaLayer.render(parameters);
12731 }
12732 }).catch(error => {
12733 console.error(error);
12734 });
12735 }
12737 cancel() {
12738 this._cancelled = true;
12739 }
12741 hide() {
12742 if (!this.div) {
12743 return;
12744 }
12746 this.div.hidden = true;
12747 }
12749 }
12751 exports.XfaLayerBuilder = XfaLayerBuilder;
12753 class DefaultXfaLayerFactory {
12754 createXfaLayerBuilder(pageDiv, pdfPage, annotationStorage = null, xfaHtml = null) {
12755 return new XfaLayerBuilder({
12756 pageDiv,
12757 pdfPage,
12758 annotationStorage,
12759 xfaHtml
12760 });
12761 }
12763 }
12765 exports.DefaultXfaLayerFactory = DefaultXfaLayerFactory;
12767 /***/ }),
12768 /* 35 */
12769 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
12774 value: true
12775 }));
12776 exports.SecondaryToolbar = void 0;
12778 var _ui_utils = __webpack_require__(4);
12780 var _pdf_cursor_tools = __webpack_require__(6);
12782 var _pdf_single_page_viewer = __webpack_require__(36);
12784 class SecondaryToolbar {
12785 constructor(options, mainContainer, eventBus) {
12786 this.toolbar = options.toolbar;
12787 this.toggleButton = options.toggleButton;
12788 this.toolbarButtonContainer = options.toolbarButtonContainer;
12789 this.buttons = [{
12790 element: options.presentationModeButton,
12792 close: true
12793 }, {
12794 element: options.openFileButton,
12796 close: true
12797 }, {
12798 element: options.printButton,
12800 close: true
12801 }, {
12802 element: options.downloadButton,
12804 close: true
12805 }, {
12806 element: options.viewBookmarkButton,
12807 eventName: null,
12808 close: true
12809 }, {
12810 element: options.firstPageButton,
12812 close: true
12813 }, {
12814 element: options.lastPageButton,
12816 close: true
12817 }, {
12818 element: options.pageRotateCwButton,
12820 close: false
12821 }, {
12822 element: options.pageRotateCcwButton,
12824 close: false
12825 }, {
12826 element: options.cursorSelectToolButton,
12828 eventDetails: {
12829 tool: _pdf_cursor_tools.CursorTool.SELECT
12830 },
12831 close: true
12832 }, {
12833 element: options.cursorHandToolButton,
12835 eventDetails: {
12836 tool: _pdf_cursor_tools.CursorTool.HAND
12837 },
12838 close: true
12839 }, {
12840 element: options.scrollVerticalButton,
12842 eventDetails: {
12843 mode: _ui_utils.ScrollMode.VERTICAL
12844 },
12845 close: true
12846 }, {
12847 element: options.scrollHorizontalButton,
12849 eventDetails: {
12850 mode: _ui_utils.ScrollMode.HORIZONTAL
12851 },
12852 close: true
12853 }, {
12854 element: options.scrollWrappedButton,
12856 eventDetails: {
12857 mode: _ui_utils.ScrollMode.WRAPPED
12858 },
12859 close: true
12860 }, {
12861 element: options.spreadNoneButton,
12863 eventDetails: {
12864 mode: _ui_utils.SpreadMode.NONE
12865 },
12866 close: true
12867 }, {
12868 element: options.spreadOddButton,
12870 eventDetails: {
12871 mode: _ui_utils.SpreadMode.ODD
12872 },
12873 close: true
12874 }, {
12875 element: options.spreadEvenButton,
12877 eventDetails: {
12878 mode: _ui_utils.SpreadMode.EVEN
12879 },
12880 close: true
12881 }, {
12882 element: options.documentPropertiesButton,
12884 close: true
12885 }];
12886 this.items = {
12887 firstPage: options.firstPageButton,
12888 lastPage: options.lastPageButton,
12889 pageRotateCw: options.pageRotateCwButton,
12890 pageRotateCcw: options.pageRotateCcwButton
12891 };
12892 this.mainContainer = mainContainer;
12893 this.eventBus = eventBus;
12894 this.opened = false;
12895 this.containerHeight = null;
12896 this.previousContainerHeight = null;
12897 this.reset();
12899 this._bindClickListeners();
12901 this._bindCursorToolsListener(options);
12903 this._bindScrollModeListener(options);
12905 this._bindSpreadModeListener(options);
12910 if (evt.source instanceof _pdf_single_page_viewer.PDFSinglePageViewer) {
12911 this.toolbarButtonContainer.classList.add("hiddenScrollModeButtons", "hiddenSpreadModeButtons");
12912 } else {
12913 this.toolbarButtonContainer.classList.remove("hiddenScrollModeButtons", "hiddenSpreadModeButtons");
12914 }
12915 });
12916 }
12918 get isOpen() {
12919 return this.opened;
12920 }
12922 setPageNumber(pageNumber) {
12923 this.pageNumber = pageNumber;
12925 this._updateUIState();
12926 }
12928 setPagesCount(pagesCount) {
12929 this.pagesCount = pagesCount;
12931 this._updateUIState();
12932 }
12934 reset() {
12935 this.pageNumber = 0;
12936 this.pagesCount = 0;
12938 this._updateUIState();
12941 source: this
12942 });
12943 }
12945 _updateUIState() {
12946 this.items.firstPage.disabled = this.pageNumber <= 1;
12947 this.items.lastPage.disabled = this.pageNumber >= this.pagesCount;
12948 this.items.pageRotateCw.disabled = this.pagesCount === 0;
12949 this.items.pageRotateCcw.disabled = this.pagesCount === 0;
12950 }
12952 _bindClickListeners() {
12955 for (const {
12956 element,
12957 eventName,
12958 close,
12959 eventDetails
12960 } of this.buttons) {
12962 if (eventName !== null) {
12963 const details = {
12964 source: this
12965 };
12967 for (const property in eventDetails) {
12968 details[property] = eventDetails[property];
12969 }
12971 this.eventBus.dispatch(eventName, details);
12972 }
12974 if (close) {
12975 this.close();
12976 }
12977 });
12978 }
12979 }
12981 _bindCursorToolsListener(buttons) {
12983 tool
12984 }) {
12985 buttons.cursorSelectToolButton.classList.toggle("toggled", tool === _pdf_cursor_tools.CursorTool.SELECT);
12986 buttons.cursorHandToolButton.classList.toggle("toggled", tool === _pdf_cursor_tools.CursorTool.HAND);
12987 });
12988 }
12990 _bindScrollModeListener(buttons) {
12991 function scrollModeChanged({
12992 mode
12993 }) {
12994 buttons.scrollVerticalButton.classList.toggle("toggled", mode === _ui_utils.ScrollMode.VERTICAL);
12995 buttons.scrollHorizontalButton.classList.toggle("toggled", mode === _ui_utils.ScrollMode.HORIZONTAL);
12996 buttons.scrollWrappedButton.classList.toggle("toggled", mode === _ui_utils.ScrollMode.WRAPPED);
12997 const isScrollModeHorizontal = mode === _ui_utils.ScrollMode.HORIZONTAL;
12998 buttons.spreadNoneButton.disabled = isScrollModeHorizontal;
12999 buttons.spreadOddButton.disabled = isScrollModeHorizontal;
13000 buttons.spreadEvenButton.disabled = isScrollModeHorizontal;
13001 }
13006 if (evt.source === this) {
13007 scrollModeChanged({
13008 mode: _ui_utils.ScrollMode.VERTICAL
13009 });
13010 }
13011 });
13012 }
13014 _bindSpreadModeListener(buttons) {
13015 function spreadModeChanged({
13016 mode
13017 }) {
13021 }
13026 if (evt.source === this) {
13027 spreadModeChanged({
13028 mode: _ui_utils.SpreadMode.NONE
13029 });
13030 }
13031 });
13032 }
13034 open() {
13035 if (this.opened) {
13036 return;
13037 }
13039 this.opened = true;
13041 this._setMaxHeight();
13046 }
13048 close() {
13049 if (!this.opened) {
13050 return;
13051 }
13053 this.opened = false;
13057 }
13059 toggle() {
13060 if (this.opened) {
13061 this.close();
13062 } else {
13063 this.open();
13064 }
13065 }
13067 _setMaxHeight() {
13068 if (!this.opened) {
13069 return;
13070 }
13072 this.containerHeight = this.mainContainer.clientHeight;
13074 if (this.containerHeight === this.previousContainerHeight) {
13075 return;
13076 }
13078 this.toolbarButtonContainer.style.maxHeight = `${this.containerHeight - _ui_utils.SCROLLBAR_PADDING}px`;
13079 this.previousContainerHeight = this.containerHeight;
13080 }
13082 }
13084 exports.SecondaryToolbar = SecondaryToolbar;
13086 /***/ }),
13087 /* 36 */
13088 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
13093 value: true
13094 }));
13095 exports.PDFSinglePageViewer = void 0;
13097 var _base_viewer = __webpack_require__(28);
13099 var _pdfjsLib = __webpack_require__(5);
13101 class PDFSinglePageViewer extends _base_viewer.BaseViewer {
13102 constructor(options) {
13103 super(options);
13106 this._ensurePageViewVisible();
13107 });
13108 }
13110 get _viewerElement() {
13112 }
13114 get _pageWidthScaleFactor() {
13115 return 1;
13116 }
13118 _resetView() {
13119 super._resetView();
13121 this._previousPageNumber = 1;
13122 this._shadowViewer = document.createDocumentFragment();
13123 this._updateScrollDown = null;
13124 }
13126 _ensurePageViewVisible() {
13127 const pageView = this._pages[this._currentPageNumber - 1];
13128 const previousPageView = this._pages[this._previousPageNumber - 1];
13129 const viewerNodes = this.viewer.childNodes;
13131 switch (viewerNodes.length) {
13132 case 0:
13133 this.viewer.appendChild(pageView.div);
13134 break;
13136 case 1:
13137 if (viewerNodes[0] !== previousPageView.div) {
13139 }
13141 if (pageView === previousPageView) {
13142 break;
13143 }
13145 this._shadowViewer.appendChild(previousPageView.div);
13147 this.viewer.appendChild(pageView.div);
13148 this.container.scrollTop = 0;
13149 break;
13151 default:
13153 }
13155 this._previousPageNumber = this._currentPageNumber;
13156 }
13158 _scrollUpdate() {
13159 if (this._updateScrollDown) {
13160 this._updateScrollDown();
13161 }
13163 super._scrollUpdate();
13164 }
13166 _scrollIntoView({
13167 pageDiv,
13168 pageSpot = null,
13169 pageNumber = null
13170 }) {
13171 if (pageNumber) {
13172 this._setCurrentPageNumber(pageNumber);
13173 }
13175 const scrolledDown = this._currentPageNumber >= this._previousPageNumber;
13177 this._ensurePageViewVisible();
13179 this.update();
13181 super._scrollIntoView({
13182 pageDiv,
13183 pageSpot,
13184 pageNumber
13185 });
13187 this._updateScrollDown = () => {
13188 this.scroll.down = scrolledDown;
13189 this._updateScrollDown = null;
13190 };
13191 }
13193 _getVisiblePages() {
13194 return this._getCurrentVisiblePage();
13195 }
13197 _updateHelper(visiblePages) {}
13199 get _isScrollModeHorizontal() {
13201 }
13203 _updateScrollMode() {}
13205 _updateSpreadMode() {}
13207 _getPageAdvance() {
13208 return 1;
13209 }
13211 }
13213 exports.PDFSinglePageViewer = PDFSinglePageViewer;
13215 /***/ }),
13216 /* 37 */
13217 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
13222 value: true
13223 }));
13224 exports.Toolbar = void 0;
13226 var _ui_utils = __webpack_require__(4);
13229 const SCALE_SELECT_CONTAINER_WIDTH = 140;
13230 const SCALE_SELECT_WIDTH = 162;
13232 class Toolbar {
13233 constructor(options, eventBus, l10n) {
13234 this.toolbar = options.container;
13235 this.eventBus = eventBus;
13236 this.l10n = l10n;
13237 this.buttons = [{
13238 element: options.previous,
13240 }, {
13241 element: options.next,
13243 }, {
13244 element: options.zoomIn,
13246 }, {
13247 element: options.zoomOut,
13249 }, {
13250 element: options.openFile,
13252 }, {
13253 element: options.print,
13255 }, {
13256 element: options.presentationModeButton,
13258 }, {
13259 element: options.download,
13261 }, {
13262 element: options.viewBookmark,
13263 eventName: null
13264 }];
13265 this.items = {
13266 numPages: options.numPages,
13267 pageNumber: options.pageNumber,
13268 scaleSelectContainer: options.scaleSelectContainer,
13269 scaleSelect: options.scaleSelect,
13270 customScaleOption: options.customScaleOption,
13271 previous: options.previous,
13272 next: options.next,
13273 zoomIn: options.zoomIn,
13274 zoomOut: options.zoomOut
13275 };
13276 this._wasLocalized = false;
13277 this.reset();
13279 this._bindListeners();
13280 }
13282 setPageNumber(pageNumber, pageLabel) {
13283 this.pageNumber = pageNumber;
13284 this.pageLabel = pageLabel;
13286 this._updateUIState(false);
13287 }
13289 setPagesCount(pagesCount, hasPageLabels) {
13290 this.pagesCount = pagesCount;
13291 this.hasPageLabels = hasPageLabels;
13293 this._updateUIState(true);
13294 }
13296 setPageScale(pageScaleValue, pageScale) {
13297 this.pageScaleValue = (pageScaleValue || pageScale).toString();
13298 this.pageScale = pageScale;
13300 this._updateUIState(false);
13301 }
13303 reset() {
13304 this.pageNumber = 0;
13305 this.pageLabel = null;
13306 this.hasPageLabels = false;
13307 this.pagesCount = 0;
13308 this.pageScaleValue = _ui_utils.DEFAULT_SCALE_VALUE;
13309 this.pageScale = _ui_utils.DEFAULT_SCALE;
13311 this._updateUIState(true);
13313 this.updateLoadingIndicatorState();
13314 }
13316 _bindListeners() {
13317 const {
13318 pageNumber,
13319 scaleSelect
13320 } = this.items;
13321 const self = this;
13323 for (const {
13324 element,
13325 eventName
13326 } of this.buttons) {
13328 if (eventName !== null) {
13329 this.eventBus.dispatch(eventName, {
13330 source: this
13331 });
13332 }
13333 });
13334 }
13337 this.select();
13338 });
13341 source: self,
13342 value: this.value
13343 });
13344 });
13347 return;
13348 }
13351 source: self,
13352 value: this.value
13353 });
13354 });
13356 const target = evt.target;
13359 this.blur();
13360 }
13361 });
13362 scaleSelect.oncontextmenu = _ui_utils.noContextMenuHandler;
13365 this._wasLocalized = true;
13367 this._adjustScaleWidth();
13369 this._updateUIState(true);
13370 });
13371 }
13373 _updateUIState(resetNumPages = false) {
13374 if (!this._wasLocalized) {
13375 return;
13376 }
13378 const {
13379 pageNumber,
13380 pagesCount,
13381 pageScaleValue,
13382 pageScale,
13383 items
13384 } = this;
13386 if (resetNumPages) {
13387 if (this.hasPageLabels) {
13389 } else {
13392 pagesCount
13393 }).then(msg => {
13394 items.numPages.textContent = msg;
13395 });
13396 }
13398 items.pageNumber.max = pagesCount;
13399 }
13401 if (this.hasPageLabels) {
13402 items.pageNumber.value = this.pageLabel;
13404 pageNumber,
13405 pagesCount
13406 }).then(msg => {
13407 items.numPages.textContent = msg;
13408 });
13409 } else {
13410 items.pageNumber.value = pageNumber;
13411 }
13413 items.previous.disabled = pageNumber <= 1;
13414 items.next.disabled = pageNumber >= pagesCount;
13415 items.zoomOut.disabled = pageScale <= _ui_utils.MIN_SCALE;
13416 items.zoomIn.disabled = pageScale >= _ui_utils.MAX_SCALE;
13418 scale: Math.round(pageScale * 10000) / 100
13419 }).then(msg => {
13420 let predefinedValueFound = false;
13422 for (const option of items.scaleSelect.options) {
13423 if (option.value !== pageScaleValue) {
13424 option.selected = false;
13425 continue;
13426 }
13428 option.selected = true;
13429 predefinedValueFound = true;
13430 }
13432 if (!predefinedValueFound) {
13433 items.customScaleOption.textContent = msg;
13434 items.customScaleOption.selected = true;
13435 }
13436 });
13437 }
13439 updateLoadingIndicatorState(loading = false) {
13440 const pageNumberInput = this.items.pageNumber;
13441 pageNumberInput.classList.toggle(PAGE_NUMBER_LOADING_INDICATOR, loading);
13442 }
13444 async _adjustScaleWidth() {
13445 const {
13446 items,
13447 l10n
13448 } = this;
13449 const predefinedValuesPromise = Promise.all([l10n.get("page_scale_auto"), l10n.get("page_scale_actual"), l10n.get("page_scale_fit"), l10n.get("page_scale_width")]);
13451 canvas.mozOpaque = true;
13453 alpha: false
13454 });
13455 await _ui_utils.animationStarted;
13456 const {
13457 fontSize,
13458 fontFamily
13459 } = getComputedStyle(items.scaleSelect);
13461 let maxWidth = 0;
13463 for (const predefinedValue of await predefinedValuesPromise) {
13464 const {
13465 width
13466 } = ctx.measureText(predefinedValue);
13468 if (width > maxWidth) {
13469 maxWidth = width;
13470 }
13471 }
13473 const overflow = SCALE_SELECT_WIDTH - SCALE_SELECT_CONTAINER_WIDTH;
13474 maxWidth += 2 * overflow;
13476 if (maxWidth > SCALE_SELECT_CONTAINER_WIDTH) {
13479 }
13481 canvas.width = 0;
13482 canvas.height = 0;
13483 canvas = ctx = null;
13484 }
13486 }
13488 exports.Toolbar = Toolbar;
13490 /***/ }),
13491 /* 38 */
13492 /***/ ((__unused_webpack_module, exports) => {
13497 value: true
13498 }));
13499 exports.ViewHistory = void 0;
13500 const DEFAULT_VIEW_HISTORY_CACHE_SIZE = 20;
13502 class ViewHistory {
13503 constructor(fingerprint, cacheSize = DEFAULT_VIEW_HISTORY_CACHE_SIZE) {
13504 this.fingerprint = fingerprint;
13505 this.cacheSize = cacheSize;
13506 this._initializedPromise = this._readFromStorage().then(databaseStr => {
13508 let index = -1;
13510 if (!Array.isArray(database.files)) {
13511 database.files = [];
13512 } else {
13513 while (database.files.length >= this.cacheSize) {
13514 database.files.shift();
13515 }
13517 for (let i = 0, ii = database.files.length; i < ii; i++) {
13518 const branch = database.files[i];
13520 if (branch.fingerprint === this.fingerprint) {
13521 index = i;
13522 break;
13523 }
13524 }
13525 }
13527 if (index === -1) {
13528 index = database.files.push({
13529 fingerprint: this.fingerprint
13530 }) - 1;
13531 }
13533 this.file = database.files[index];
13534 this.database = database;
13535 });
13536 }
13538 async _writeToStorage() {
13539 const databaseStr = JSON.stringify(this.database);
13541 }
13543 async _readFromStorage() {
13545 }
13547 async set(name, val) {
13548 await this._initializedPromise;
13549 this.file[name] = val;
13550 return this._writeToStorage();
13551 }
13553 async setMultiple(properties) {
13554 await this._initializedPromise;
13556 for (const name in properties) {
13557 this.file[name] = properties[name];
13558 }
13560 return this._writeToStorage();
13561 }
13563 async get(name, defaultValue) {
13564 await this._initializedPromise;
13565 const val = this.file[name];
13566 return val !== undefined ? val : defaultValue;
13567 }
13569 async getMultiple(properties) {
13570 await this._initializedPromise;
13571 const values = Object.create(null);
13573 for (const name in properties) {
13574 const val = this.file[name];
13575 values[name] = val !== undefined ? val : properties[name];
13576 }
13578 return values;
13579 }
13581 }
13583 exports.ViewHistory = ViewHistory;
13585 /***/ }),
13586 /* 39 */
13587 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
13592 value: true
13593 }));
13594 exports.GenericCom = void 0;
13596 var _app = __webpack_require__(3);
13598 var _preferences = __webpack_require__(40);
13600 var _download_manager = __webpack_require__(41);
13602 var _genericl10n = __webpack_require__(42);
13604 var _generic_scripting = __webpack_require__(44);
13606 ;
13607 const GenericCom = {};
13608 exports.GenericCom = GenericCom;
13610 class GenericPreferences extends _preferences.BasePreferences {
13611 async _writeToStorage(prefObj) {
13613 }
13615 async _readFromStorage(prefObj) {
13617 }
13619 }
13621 class GenericExternalServices extends _app.DefaultExternalServices {
13622 static createDownloadManager(options) {
13623 return new _download_manager.DownloadManager();
13624 }
13626 static createPreferences() {
13627 return new GenericPreferences();
13628 }
13630 static createL10n({
13632 }) {
13633 return new _genericl10n.GenericL10n(locale);
13634 }
13636 static createScripting({
13637 sandboxBundleSrc
13638 }) {
13639 return new _generic_scripting.GenericScripting(sandboxBundleSrc);
13640 }
13642 }
13644 _app.PDFViewerApplication.externalServices = GenericExternalServices;
13646 /***/ }),
13647 /* 40 */
13648 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
13653 value: true
13654 }));
13655 exports.BasePreferences = void 0;
13657 var _app_options = __webpack_require__(1);
13659 class BasePreferences {
13660 constructor() {
13661 if (this.constructor === BasePreferences) {
13663 }
13666 value: Object.freeze({
13691 }),
13692 writable: false,
13693 enumerable: true,
13694 configurable: false
13695 });
13696 this.prefs = Object.create(null);
13697 this._initializedPromise = this._readFromStorage(this.defaults).then(prefs => {
13698 for (const name in this.defaults) {
13699 const prefValue = prefs?.[name];
13701 if (typeof prefValue === typeof this.defaults[name]) {
13702 this.prefs[name] = prefValue;
13703 }
13704 }
13705 });
13706 }
13708 async _writeToStorage(prefObj) {
13710 }
13712 async _readFromStorage(prefObj) {
13714 }
13716 async reset() {
13717 await this._initializedPromise;
13718 this.prefs = Object.create(null);
13719 return this._writeToStorage(this.defaults);
13720 }
13722 async set(name, value) {
13723 await this._initializedPromise;
13724 const defaultValue = this.defaults[name];
13726 if (defaultValue === undefined) {
13728 } else if (value === undefined) {
13730 }
13732 const valueType = typeof value;
13733 const defaultType = typeof defaultValue;
13735 if (valueType !== defaultType) {
13737 value = value.toString();
13738 } else {
13740 }
13741 } else {
13744 }
13745 }
13747 this.prefs[name] = value;
13748 return this._writeToStorage(this.prefs);
13749 }
13751 async get(name) {
13752 await this._initializedPromise;
13753 const defaultValue = this.defaults[name],
13754 prefValue = this.prefs[name];
13756 if (defaultValue === undefined) {
13758 }
13760 return prefValue !== undefined ? prefValue : defaultValue;
13761 }
13763 async getAll() {
13764 await this._initializedPromise;
13765 const obj = Object.create(null);
13767 for (const name in this.defaults) {
13768 const prefValue = this.prefs[name];
13769 obj[name] = prefValue !== undefined ? prefValue : this.defaults[name];
13770 }
13772 return obj;
13773 }
13775 }
13777 exports.BasePreferences = BasePreferences;
13779 /***/ }),
13780 /* 41 */
13781 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
13786 value: true
13787 }));
13788 exports.DownloadManager = void 0;
13790 var _pdfjsLib = __webpack_require__(5);
13792 var _viewer_compatibility = __webpack_require__(2);
13794 ;
13796 function download(blobUrl, filename) {
13799 if (!a.click) {
13801 }
13803 a.href = blobUrl;
13807 a.download = filename;
13808 }
13810 (document.body || document.documentElement).appendChild(a);
13811 a.click();
13812 a.remove();
13813 }
13815 class DownloadManager {
13816 constructor() {
13817 this._openBlobUrls = new WeakMap();
13818 }
13820 downloadUrl(url, filename) {
13823 }
13826 }
13829 const blobUrl = (0, _pdfjsLib.createObjectURL)(data, contentType, _viewer_compatibility.viewerCompatibilityParams.disableCreateObjectURL);
13831 }
13842 type: contentType
13843 }));
13846 }
13859 }
13860 }
13864 }
13870 }
13874 }
13876 }
13881 /* 42 */
13888 }));
13903 });
13904 });
13905 }
13910 }
13915 }
13920 }
13925 }
13927 }
13932 /* 43 */
13948 }
13953 }
13957 }
13970 }
13971 }
13975 args: args
13976 };
13977 }
13989 }
13997 }
13998 }
13999 };
14008 }
14009 }
14016 return text.replace(/\\\\/g, '\\').replace(/\\n/g, '\n').replace(/\\r/g, '\r').replace(/\\t/g, '\t').replace(/\\b/g, '\b').replace(/\\f/g, '\f').replace(/\\{/g, '{').replace(/\\}/g, '}').replace(/\\"/g, '"').replace(/\\'/g, "'");
14017 }
14039 }
14053 }
14060 }
14061 }
14067 }
14068 }
14069 }
14072 }
14080 });
14081 }
14085 });
14086 }
14093 prop,
14102 }
14106 }
14109 }
14113 }
14114 });
14116 }
14121 }
14148 }
14149 }
14150 }
14155 }
14159 }
14165 gResourceCount++;
14170 }
14171 };
14182 });
14183 };
14184 }
14189 }
14190 }
14193 gL10nData = {};
14196 }
14370 };
14374 }
14378 }
14383 },
14391 },
14397 },
14401 },
14405 },
14409 },
14414 },
14419 },
14426 },
14431 },
14436 },
14442 },
14447 },
14450 if (n != 1 && isBetween(n % 10, 0, 1) || isBetween(n % 10, 5, 9) || isBetween(n % 100, 12, 14)) return 'many';
14453 },
14459 },
14465 },
14469 },
14477 },
14482 },
14487 },
14489 if ((isBetween(n % 10, 3, 4) || n % 10 == 9) && !(isBetween(n % 100, 10, 19) || isBetween(n % 100, 70, 79) || isBetween(n % 100, 90, 99))) return 'few';
14494 },
14499 },
14503 },
14507 },
14513 }
14514 };
14521 };
14522 }
14525 }
14534 }
14548 }
14551 };
14561 }
14564 }
14573 }
14576 }
14590 }
14595 }
14598 }
14605 }
14609 }
14613 });
14614 }
14624 }
14640 }
14641 }
14642 }
14647 }
14648 }
14651 }
14655 }
14656 }
14661 }
14665 }
14671 }
14674 }
14683 }
14686 }
14696 }
14701 fallback = {};
14703 }
14709 }
14712 },
14715 },
14718 },
14721 },
14725 });
14726 },
14731 },
14735 },
14742 });
14747 });
14748 }
14749 }
14750 };
14754 /* 44 */
14761 }));
14771 info,
14772 metadata,
14773 contentDispositionFilename,
14774 contentLength
14779 length
14782 }
14791 URL: url
14792 };
14793 }
14799 });
14800 }
14805 }
14810 }
14815 }
14817 }
14822 /* 45 */
14829 }));
14841 function renderPage(activeServiceOnEntry, pdfDocument, pageNumber, size, printResolution, optionalContentConfigPromise) {
14858 }),
14861 optionalContentConfigPromise
14862 };
14864 });
14865 }
14867 function PDFPrintService(pdfDocument, pagesOverview, printContainer, printResolution, optionalContentConfigPromise = null, l10n) {
14872 this._optionalContentConfigPromise = optionalContentConfigPromise || pdfDocument.getOptionalContentConfig();
14876 }
14884 return size.width === this.pagesOverview[0].width && size.height === this.pagesOverview[0].height;
14889 }
14893 this.pageStyleSheet.textContent = "@page { size: " + pageSize.width + "pt " + pageSize.height + "pt;}";
14895 },
14900 }
14909 }
14917 }
14920 });
14921 },
14927 }
14938 }
14942 renderPage(this, this.pdfDocument, index + 1, this.pagesOverview[index], this._printResolution, this._optionalContentConfigPromise).then(this.useRenderedPage.bind(this)).then(function () {
14945 };
14948 },
14955 if ("toBlob" in scratchCanvas && !_viewer_compatibility.viewerCompatibilityParams.disableCreateObjectURL) {
14958 });
14961 }
14970 });
14971 },
14980 }
14985 });
14986 },
14990 },
14995 }
14996 }
14998 };
15005 }
15010 }
15011 });
15021 }
15022 });
15024 }
15032 }
15033 });
15034 }
15035 };
15041 }
15047 }
15048 }
15057 progress
15060 });
15061 }
15064 if (event.keyCode === 80 && (event.ctrlKey || event.metaKey) && !event.altKey && (!event.shiftKey || window.chrome || window.opera)) {
15072 }
15073 }
15080 }
15081 };
15085 }
15095 }
15097 overlayPromise = overlayManager.register("printServiceOverlay", document.getElementById("printServiceOverlay"), abort, true);
15099 }
15102 }
15107 createPrintService(pdfDocument, pagesOverview, printContainer, printResolution, optionalContentConfigPromise, l10n) {
15110 }
15112 activeService = new PDFPrintService(pdfDocument, pagesOverview, printContainer, printResolution, optionalContentConfigPromise, l10n);
15114 }
15116 };
15119 /* 46 */
15126 }));
15144 const builder = factory.createXfaLayerBuilder(page, null, pdfDocument.annotationStorage, xfaPage);
15146 scale
15147 });
15149 }
15150 }
15154 /************************************************************************/
15157 /******/
15171 /******/
15174 /******/
15178 /******/
15179 /************************************************************************/
15181 // This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
15182 (() => {
15188 }));
15193 }
15194 }));
15199 }
15200 }));
15210 ;
15211 ;
15212 {
15214 }
15215 ;
15216 {
15218 }
15222 errorWrapper = {
15229 };
15235 toolbar: {
15252 },
15253 secondaryToolbar: {
15275 },
15276 sidebar: {
15290 },
15291 sidebarResizer: {
15294 },
15295 findBar: {
15306 },
15307 passwordOverlay: {
15314 },
15315 documentProperties: {
15319 fields: {
15334 }
15335 },
15336 errorWrapper,
15340 };
15341 }
15347 source: window
15348 });
15355 }
15358 }
15362 }
15368 }
15369 })();
15372 ;
15373 //# sourceMappingURL=viewer.js.map