feat(pdf): fix formatting of copied text (#4564)

* chore(pdf): update pdfjs to 2.13.216

Also reapplied pdf_viewer fix from d3b4773.

* fix(pdf): formatting of copied text

* chore(pdf): update viewer CSS to 2.13.216

* chore(pdf): remove deprecated option

* chore(pdf): update pdfjs to 2.14.305

* doc(pdf): document some functions

* fix(pdf): highlight positioning

resources/js/pdfjs/pdf_viewer.js

@@ -1,8 +1,8 @@
 /**
  * @licstart The following is the entire license notice for the
- * Javascript code in this page
+ * JavaScript code in this page
  *
- * Copyright 2021 Mozilla Foundation
+ * Copyright 2022 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,7521 +17,8550 @@
  * limitations under the License.
  *
  * @licend The above is the entire license notice for the
- * Javascript code in this page
+ * JavaScript code in this page
  */
 
-(function webpackUniversalModuleDefinition (root, factory) {
-  if (typeof exports === 'object' && typeof module === 'object')
-    module.exports = factory()
-  else if (typeof define === 'function' && define.amd)
-    define('pdfjs-dist/web/pdf_viewer', [], factory)
-  else if (typeof exports === 'object')
-    exports['pdfjs-dist/web/pdf_viewer'] = factory()
-  else
-    root['pdfjs-dist/web/pdf_viewer'] = root.pdfjsViewer = factory()
-})(this, function () {
-  return /******/ (() => { // webpackBootstrap
-    /******/
-    'use strict'
-    /******/
-    var __webpack_modules__ = ([
-      /* 0 */,
-      /* 1 */
-      /***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
-
-        Object.defineProperty(exports, '__esModule', ({
-          value: true
-        }))
-        exports.DefaultAnnotationLayerFactory = exports.AnnotationLayerBuilder = void 0
-
-        var _pdfjsLib = __w_pdfjs_require__(2)
-
-        var _l10n_utils = __w_pdfjs_require__(3)
-
-        var _pdf_link_service = __w_pdfjs_require__(4)
-
-        class AnnotationLayerBuilder {
-          constructor ({
-            pageDiv,
-            pdfPage,
-            linkService,
-            downloadManager,
-            annotationStorage = null,
-            imageResourcesPath = '',
-            renderInteractiveForms = true,
-            l10n = _l10n_utils.NullL10n,
-            enableScripting = false,
-            hasJSActionsPromise = null,
-            mouseState = null
-          }) {
-            this.pageDiv = pageDiv
-            this.pdfPage = pdfPage
-            this.linkService = linkService
-            this.downloadManager = downloadManager
-            this.imageResourcesPath = imageResourcesPath
-            this.renderInteractiveForms = renderInteractiveForms
-            this.l10n = l10n
-            this.annotationStorage = annotationStorage
-            this.enableScripting = enableScripting
-            this._hasJSActionsPromise = hasJSActionsPromise
-            this._mouseState = mouseState
-            this.div = null
-            this._cancelled = false
-          }
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define("pdfjs-dist/web/pdf_viewer", [], factory);
+	else if(typeof exports === 'object')
+		exports["pdfjs-dist/web/pdf_viewer"] = factory();
+	else
+		root["pdfjs-dist/web/pdf_viewer"] = root.pdfjsViewer = factory();
+})(this, () => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ([
+/* 0 */,
+/* 1 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
 
-          render (viewport, intent = 'display') {
-            return Promise.all([this.pdfPage.getAnnotations({
-              intent
-            }), this._hasJSActionsPromise]).then(([annotations, hasJSActions = false]) => {
-              if (this._cancelled) {
-                return
-              }
 
-              if (annotations.length === 0) {
-                return
-              }
 
-              const parameters = {
-                viewport: viewport.clone({
-                  dontFlip: true
-                }),
-                div: this.div,
-                annotations,
-                page: this.pdfPage,
-                imageResourcesPath: this.imageResourcesPath,
-                renderInteractiveForms: this.renderInteractiveForms,
-                linkService: this.linkService,
-                downloadManager: this.downloadManager,
-                annotationStorage: this.annotationStorage,
-                enableScripting: this.enableScripting,
-                hasJSActions,
-                mouseState: this._mouseState
-              }
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.DefaultXfaLayerFactory = exports.DefaultTextLayerFactory = exports.DefaultStructTreeLayerFactory = exports.DefaultAnnotationLayerFactory = void 0;
+
+var _annotation_layer_builder = __w_pdfjs_require__(2);
+
+var _l10n_utils = __w_pdfjs_require__(4);
+
+var _pdf_link_service = __w_pdfjs_require__(5);
+
+var _struct_tree_layer_builder = __w_pdfjs_require__(7);
+
+var _text_layer_builder = __w_pdfjs_require__(8);
+
+var _xfa_layer_builder = __w_pdfjs_require__(9);
+
+class DefaultAnnotationLayerFactory {
+  createAnnotationLayerBuilder(pageDiv, pdfPage, annotationStorage = null, imageResourcesPath = "", renderForms = true, l10n = _l10n_utils.NullL10n, enableScripting = false, hasJSActionsPromise = null, mouseState = null, fieldObjectsPromise = null, annotationCanvasMap = null) {
+    return new _annotation_layer_builder.AnnotationLayerBuilder({
+      pageDiv,
+      pdfPage,
+      imageResourcesPath,
+      renderForms,
+      linkService: new _pdf_link_service.SimpleLinkService(),
+      l10n,
+      annotationStorage,
+      enableScripting,
+      hasJSActionsPromise,
+      fieldObjectsPromise,
+      mouseState,
+      annotationCanvasMap
+    });
+  }
+
+}
+
+exports.DefaultAnnotationLayerFactory = DefaultAnnotationLayerFactory;
+
+class DefaultStructTreeLayerFactory {
+  createStructTreeLayerBuilder(pdfPage) {
+    return new _struct_tree_layer_builder.StructTreeLayerBuilder({
+      pdfPage
+    });
+  }
+
+}
+
+exports.DefaultStructTreeLayerFactory = DefaultStructTreeLayerFactory;
+
+class DefaultTextLayerFactory {
+  createTextLayerBuilder(textLayerDiv, pageIndex, viewport, enhanceTextSelection = false, eventBus, highlighter) {
+    return new _text_layer_builder.TextLayerBuilder({
+      textLayerDiv,
+      pageIndex,
+      viewport,
+      enhanceTextSelection,
+      eventBus,
+      highlighter
+    });
+  }
+
+}
+
+exports.DefaultTextLayerFactory = DefaultTextLayerFactory;
+
+class DefaultXfaLayerFactory {
+  createXfaLayerBuilder(pageDiv, pdfPage, annotationStorage = null, xfaHtml = null) {
+    return new _xfa_layer_builder.XfaLayerBuilder({
+      pageDiv,
+      pdfPage,
+      annotationStorage,
+      linkService: new _pdf_link_service.SimpleLinkService(),
+      xfaHtml
+    });
+  }
+
+}
+
+exports.DefaultXfaLayerFactory = DefaultXfaLayerFactory;
+
+/***/ }),
+/* 2 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.AnnotationLayerBuilder = void 0;
+
+var _pdfjsLib = __w_pdfjs_require__(3);
+
+var _l10n_utils = __w_pdfjs_require__(4);
+
+class AnnotationLayerBuilder {
+  constructor({
+    pageDiv,
+    pdfPage,
+    linkService,
+    downloadManager,
+    annotationStorage = null,
+    imageResourcesPath = "",
+    renderForms = true,
+    l10n = _l10n_utils.NullL10n,
+    enableScripting = false,
+    hasJSActionsPromise = null,
+    fieldObjectsPromise = null,
+    mouseState = null,
+    annotationCanvasMap = null
+  }) {
+    this.pageDiv = pageDiv;
+    this.pdfPage = pdfPage;
+    this.linkService = linkService;
+    this.downloadManager = downloadManager;
+    this.imageResourcesPath = imageResourcesPath;
+    this.renderForms = renderForms;
+    this.l10n = l10n;
+    this.annotationStorage = annotationStorage;
+    this.enableScripting = enableScripting;
+    this._hasJSActionsPromise = hasJSActionsPromise;
+    this._fieldObjectsPromise = fieldObjectsPromise;
+    this._mouseState = mouseState;
+    this._annotationCanvasMap = annotationCanvasMap;
+    this.div = null;
+    this._cancelled = false;
+  }
+
+  async render(viewport, intent = "display") {
+    const [annotations, hasJSActions = false, fieldObjects = null] = await Promise.all([this.pdfPage.getAnnotations({
+      intent
+    }), this._hasJSActionsPromise, this._fieldObjectsPromise]);
+
+    if (this._cancelled || annotations.length === 0) {
+      return;
+    }
+
+    const parameters = {
+      viewport: viewport.clone({
+        dontFlip: true
+      }),
+      div: this.div,
+      annotations,
+      page: this.pdfPage,
+      imageResourcesPath: this.imageResourcesPath,
+      renderForms: this.renderForms,
+      linkService: this.linkService,
+      downloadManager: this.downloadManager,
+      annotationStorage: this.annotationStorage,
+      enableScripting: this.enableScripting,
+      hasJSActions,
+      fieldObjects,
+      mouseState: this._mouseState,
+      annotationCanvasMap: this._annotationCanvasMap
+    };
+
+    if (this.div) {
+      _pdfjsLib.AnnotationLayer.update(parameters);
+    } else {
+      this.div = document.createElement("div");
+      this.div.className = "annotationLayer";
+      this.pageDiv.appendChild(this.div);
+      parameters.div = this.div;
+
+      _pdfjsLib.AnnotationLayer.render(parameters);
+
+      this.l10n.translate(this.div);
+    }
+  }
 
-              if (this.div) {
-                _pdfjsLib.AnnotationLayer.update(parameters)
-              } else {
-                this.div = document.createElement('div')
-                this.div.className = 'annotationLayer'
-                this.pageDiv.appendChild(this.div)
-                parameters.div = this.div
+  cancel() {
+    this._cancelled = true;
+  }
 
-                _pdfjsLib.AnnotationLayer.render(parameters)
+  hide() {
+    if (!this.div) {
+      return;
+    }
 
-                this.l10n.translate(this.div)
-              }
-            })
-          }
+    this.div.hidden = true;
+  }
+
+}
+
+exports.AnnotationLayerBuilder = AnnotationLayerBuilder;
+
+/***/ }),
+/* 3 */
+/***/ ((module) => {
+
+
+
+let pdfjsLib;
+
+if (typeof window !== "undefined" && window["pdfjs-dist/build/pdf"]) {
+  pdfjsLib = window["pdfjs-dist/build/pdf"];
+} else {
+  pdfjsLib = require("../build/pdf.js");
+}
+
+module.exports = pdfjsLib;
+
+/***/ }),
+/* 4 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.NullL10n = void 0;
+exports.fixupLangCode = fixupLangCode;
+exports.getL10nFallback = getL10nFallback;
+const DEFAULT_L10N_STRINGS = {
+  of_pages: "of {{pagesCount}}",
+  page_of_pages: "({{pageNumber}} of {{pagesCount}})",
+  document_properties_kb: "{{size_kb}} KB ({{size_b}} bytes)",
+  document_properties_mb: "{{size_mb}} MB ({{size_b}} bytes)",
+  document_properties_date_string: "{{date}}, {{time}}",
+  document_properties_page_size_unit_inches: "in",
+  document_properties_page_size_unit_millimeters: "mm",
+  document_properties_page_size_orientation_portrait: "portrait",
+  document_properties_page_size_orientation_landscape: "landscape",
+  document_properties_page_size_name_a3: "A3",
+  document_properties_page_size_name_a4: "A4",
+  document_properties_page_size_name_letter: "Letter",
+  document_properties_page_size_name_legal: "Legal",
+  document_properties_page_size_dimension_string: "{{width}} × {{height}} {{unit}} ({{orientation}})",
+  document_properties_page_size_dimension_name_string: "{{width}} × {{height}} {{unit}} ({{name}}, {{orientation}})",
+  document_properties_linearized_yes: "Yes",
+  document_properties_linearized_no: "No",
+  print_progress_percent: "{{progress}}%",
+  "toggle_sidebar.title": "Toggle Sidebar",
+  "toggle_sidebar_notification2.title": "Toggle Sidebar (document contains outline/attachments/layers)",
+  additional_layers: "Additional Layers",
+  page_landmark: "Page {{page}}",
+  thumb_page_title: "Page {{page}}",
+  thumb_page_canvas: "Thumbnail of Page {{page}}",
+  find_reached_top: "Reached top of document, continued from bottom",
+  find_reached_bottom: "Reached end of document, continued from top",
+  "find_match_count[one]": "{{current}} of {{total}} match",
+  "find_match_count[other]": "{{current}} of {{total}} matches",
+  "find_match_count_limit[one]": "More than {{limit}} match",
+  "find_match_count_limit[other]": "More than {{limit}} matches",
+  find_not_found: "Phrase not found",
+  error_version_info: "PDF.js v{{version}} (build: {{build}})",
+  error_message: "Message: {{message}}",
+  error_stack: "Stack: {{stack}}",
+  error_file: "File: {{file}}",
+  error_line: "Line: {{line}}",
+  rendering_error: "An error occurred while rendering the page.",
+  page_scale_width: "Page Width",
+  page_scale_fit: "Page Fit",
+  page_scale_auto: "Automatic Zoom",
+  page_scale_actual: "Actual Size",
+  page_scale_percent: "{{scale}}%",
+  loading: "Loading…",
+  loading_error: "An error occurred while loading the PDF.",
+  invalid_file_error: "Invalid or corrupted PDF file.",
+  missing_file_error: "Missing PDF file.",
+  unexpected_response_error: "Unexpected server response.",
+  printing_not_supported: "Warning: Printing is not fully supported by this browser.",
+  printing_not_ready: "Warning: The PDF is not fully loaded for printing.",
+  web_fonts_disabled: "Web fonts are disabled: unable to use embedded PDF fonts."
+};
+
+function getL10nFallback(key, args) {
+  switch (key) {
+    case "find_match_count":
+      key = `find_match_count[${args.total === 1 ? "one" : "other"}]`;
+      break;
+
+    case "find_match_count_limit":
+      key = `find_match_count_limit[${args.limit === 1 ? "one" : "other"}]`;
+      break;
+  }
+
+  return DEFAULT_L10N_STRINGS[key] || "";
+}
+
+const PARTIAL_LANG_CODES = {
+  en: "en-US",
+  es: "es-ES",
+  fy: "fy-NL",
+  ga: "ga-IE",
+  gu: "gu-IN",
+  hi: "hi-IN",
+  hy: "hy-AM",
+  nb: "nb-NO",
+  ne: "ne-NP",
+  nn: "nn-NO",
+  pa: "pa-IN",
+  pt: "pt-PT",
+  sv: "sv-SE",
+  zh: "zh-CN"
+};
+
+function fixupLangCode(langCode) {
+  return PARTIAL_LANG_CODES[langCode?.toLowerCase()] || langCode;
+}
+
+function formatL10nValue(text, args) {
+  if (!args) {
+    return text;
+  }
+
+  return text.replace(/\{\{\s*(\w+)\s*\}\}/g, (all, name) => {
+    return name in args ? args[name] : "{{" + name + "}}";
+  });
+}
+
+const NullL10n = {
+  async getLanguage() {
+    return "en-us";
+  },
+
+  async getDirection() {
+    return "ltr";
+  },
+
+  async get(key, args = null, fallback = getL10nFallback(key, args)) {
+    return formatL10nValue(fallback, args);
+  },
+
+  async translate(element) {}
+
+};
+exports.NullL10n = NullL10n;
+
+/***/ }),
+/* 5 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.SimpleLinkService = exports.PDFLinkService = exports.LinkTarget = void 0;
+
+var _ui_utils = __w_pdfjs_require__(6);
+
+const DEFAULT_LINK_REL = "noopener noreferrer nofollow";
+const LinkTarget = {
+  NONE: 0,
+  SELF: 1,
+  BLANK: 2,
+  PARENT: 3,
+  TOP: 4
+};
+exports.LinkTarget = LinkTarget;
+
+function addLinkAttributes(link, {
+  url,
+  target,
+  rel,
+  enabled = true
+} = {}) {
+  if (!url || typeof url !== "string") {
+    throw new Error('A valid "url" parameter must provided.');
+  }
+
+  const urlNullRemoved = (0, _ui_utils.removeNullCharacters)(url);
+
+  if (enabled) {
+    link.href = link.title = urlNullRemoved;
+  } else {
+    link.href = "";
+    link.title = `Disabled: ${urlNullRemoved}`;
+
+    link.onclick = () => {
+      return false;
+    };
+  }
+
+  let targetStr = "";
+
+  switch (target) {
+    case LinkTarget.NONE:
+      break;
+
+    case LinkTarget.SELF:
+      targetStr = "_self";
+      break;
+
+    case LinkTarget.BLANK:
+      targetStr = "_blank";
+      break;
+
+    case LinkTarget.PARENT:
+      targetStr = "_parent";
+      break;
+
+    case LinkTarget.TOP:
+      targetStr = "_top";
+      break;
+  }
+
+  link.target = targetStr;
+  link.rel = typeof rel === "string" ? rel : DEFAULT_LINK_REL;
+}
+
+class PDFLinkService {
+  #pagesRefCache = new Map();
+
+  constructor({
+    eventBus,
+    externalLinkTarget = null,
+    externalLinkRel = null,
+    ignoreDestinationZoom = false
+  } = {}) {
+    this.eventBus = eventBus;
+    this.externalLinkTarget = externalLinkTarget;
+    this.externalLinkRel = externalLinkRel;
+    this.externalLinkEnabled = true;
+    this._ignoreDestinationZoom = ignoreDestinationZoom;
+    this.baseUrl = null;
+    this.pdfDocument = null;
+    this.pdfViewer = null;
+    this.pdfHistory = null;
+  }
+
+  setDocument(pdfDocument, baseUrl = null) {
+    this.baseUrl = baseUrl;
+    this.pdfDocument = pdfDocument;
+    this.#pagesRefCache.clear();
+  }
+
+  setViewer(pdfViewer) {
+    this.pdfViewer = pdfViewer;
+  }
+
+  setHistory(pdfHistory) {
+    this.pdfHistory = pdfHistory;
+  }
+
+  get pagesCount() {
+    return this.pdfDocument ? this.pdfDocument.numPages : 0;
+  }
+
+  get page() {
+    return this.pdfViewer.currentPageNumber;
+  }
+
+  set page(value) {
+    this.pdfViewer.currentPageNumber = value;
+  }
+
+  get rotation() {
+    return this.pdfViewer.pagesRotation;
+  }
+
+  set rotation(value) {
+    this.pdfViewer.pagesRotation = value;
+  }
+
+  #goToDestinationHelper(rawDest, namedDest = null, explicitDest) {
+    const destRef = explicitDest[0];
+    let pageNumber;
+
+    if (typeof destRef === "object" && destRef !== null) {
+      pageNumber = this._cachedPageNumber(destRef);
+
+      if (!pageNumber) {
+        this.pdfDocument.getPageIndex(destRef).then(pageIndex => {
+          this.cachePageRef(pageIndex + 1, destRef);
+          this.#goToDestinationHelper(rawDest, namedDest, explicitDest);
+        }).catch(() => {
+          console.error(`PDFLinkService.#goToDestinationHelper: "${destRef}" is not ` + `a valid page reference, for dest="${rawDest}".`);
+        });
+        return;
+      }
+    } else if (Number.isInteger(destRef)) {
+      pageNumber = destRef + 1;
+    } else {
+      console.error(`PDFLinkService.#goToDestinationHelper: "${destRef}" is not ` + `a valid destination reference, for dest="${rawDest}".`);
+      return;
+    }
 
-          cancel () {
-            this._cancelled = true
-          }
+    if (!pageNumber || pageNumber < 1 || pageNumber > this.pagesCount) {
+      console.error(`PDFLinkService.#goToDestinationHelper: "${pageNumber}" is not ` + `a valid page number, for dest="${rawDest}".`);
+      return;
+    }
 
-          hide () {
-            if (!this.div) {
-              return
-            }
+    if (this.pdfHistory) {
+      this.pdfHistory.pushCurrentPosition();
+      this.pdfHistory.push({
+        namedDest,
+        explicitDest,
+        pageNumber
+      });
+    }
 
-            this.div.hidden = true
-          }
+    this.pdfViewer.scrollPageIntoView({
+      pageNumber,
+      destArray: explicitDest,
+      ignoreDestinationZoom: this._ignoreDestinationZoom
+    });
+  }
 
-        }
+  async goToDestination(dest) {
+    if (!this.pdfDocument) {
+      return;
+    }
 
-        exports.AnnotationLayerBuilder = AnnotationLayerBuilder
-
-        class DefaultAnnotationLayerFactory {
-          createAnnotationLayerBuilder (pageDiv, pdfPage, annotationStorage = null, imageResourcesPath = '', renderInteractiveForms = true, l10n = _l10n_utils.NullL10n, enableScripting = false, hasJSActionsPromise = null, mouseState = null) {
-            return new AnnotationLayerBuilder({
-              pageDiv,
-              pdfPage,
-              imageResourcesPath,
-              renderInteractiveForms,
-              linkService: new _pdf_link_service.SimpleLinkService(),
-              l10n,
-              annotationStorage,
-              enableScripting,
-              hasJSActionsPromise,
-              mouseState
-            })
-          }
+    let namedDest, explicitDest;
 
-        }
+    if (typeof dest === "string") {
+      namedDest = dest;
+      explicitDest = await this.pdfDocument.getDestination(dest);
+    } else {
+      namedDest = null;
+      explicitDest = await dest;
+    }
 
-        exports.DefaultAnnotationLayerFactory = DefaultAnnotationLayerFactory
+    if (!Array.isArray(explicitDest)) {
+      console.error(`PDFLinkService.goToDestination: "${explicitDest}" is not ` + `a valid destination array, for dest="${dest}".`);
+      return;
+    }
 
-        /***/
-      }),
-      /* 2 */
-      /***/ ((module) => {
+    this.#goToDestinationHelper(dest, namedDest, explicitDest);
+  }
 
-        let pdfjsLib
+  goToPage(val) {
+    if (!this.pdfDocument) {
+      return;
+    }
 
-        if (typeof window !== 'undefined' && window['pdfjs-dist/build/pdf']) {
-          pdfjsLib = window['pdfjs-dist/build/pdf']
-        } else {
-          pdfjsLib = require('../build/pdf.js')
-        }
+    const pageNumber = typeof val === "string" && this.pdfViewer.pageLabelToPageNumber(val) || val | 0;
 
-        module.exports = pdfjsLib
+    if (!(Number.isInteger(pageNumber) && pageNumber > 0 && pageNumber <= this.pagesCount)) {
+      console.error(`PDFLinkService.goToPage: "${val}" is not a valid page.`);
+      return;
+    }
 
-        /***/
-      }),
-      /* 3 */
-      /***/ ((__unused_webpack_module, exports) => {
-
-        Object.defineProperty(exports, '__esModule', ({
-          value: true
-        }))
-        exports.getL10nFallback = getL10nFallback
-        exports.NullL10n = void 0
-        const DEFAULT_L10N_STRINGS = {
-          of_pages: 'of {{pagesCount}}',
-          page_of_pages: '({{pageNumber}} of {{pagesCount}})',
-          document_properties_kb: '{{size_kb}} KB ({{size_b}} bytes)',
-          document_properties_mb: '{{size_mb}} MB ({{size_b}} bytes)',
-          document_properties_date_string: '{{date}}, {{time}}',
-          document_properties_page_size_unit_inches: 'in',
-          document_properties_page_size_unit_millimeters: 'mm',
-          document_properties_page_size_orientation_portrait: 'portrait',
-          document_properties_page_size_orientation_landscape: 'landscape',
-          document_properties_page_size_name_a3: 'A3',
-          document_properties_page_size_name_a4: 'A4',
-          document_properties_page_size_name_letter: 'Letter',
-          document_properties_page_size_name_legal: 'Legal',
-          document_properties_page_size_dimension_string: '{{width}} × {{height}} {{unit}} ({{orientation}})',
-          document_properties_page_size_dimension_name_string: '{{width}} × {{height}} {{unit}} ({{name}}, {{orientation}})',
-          document_properties_linearized_yes: 'Yes',
-          document_properties_linearized_no: 'No',
-          print_progress_percent: '{{progress}}%',
-          'toggle_sidebar.title': 'Toggle Sidebar',
-          'toggle_sidebar_notification2.title': 'Toggle Sidebar (document contains outline/attachments/layers)',
-          additional_layers: 'Additional Layers',
-          page_landmark: 'Page {{page}}',
-          thumb_page_title: 'Page {{page}}',
-          thumb_page_canvas: 'Thumbnail of Page {{page}}',
-          find_reached_top: 'Reached top of document, continued from bottom',
-          find_reached_bottom: 'Reached end of document, continued from top',
-          'find_match_count[one]': '{{current}} of {{total}} match',
-          'find_match_count[other]': '{{current}} of {{total}} matches',
-          'find_match_count_limit[one]': 'More than {{limit}} match',
-          'find_match_count_limit[other]': 'More than {{limit}} matches',
-          find_not_found: 'Phrase not found',
-          error_version_info: 'PDF.js v{{version}} (build: {{build}})',
-          error_message: 'Message: {{message}}',
-          error_stack: 'Stack: {{stack}}',
-          error_file: 'File: {{file}}',
-          error_line: 'Line: {{line}}',
-          rendering_error: 'An error occurred while rendering the page.',
-          page_scale_width: 'Page Width',
-          page_scale_fit: 'Page Fit',
-          page_scale_auto: 'Automatic Zoom',
-          page_scale_actual: 'Actual Size',
-          page_scale_percent: '{{scale}}%',
-          loading: 'Loading…',
-          loading_error: 'An error occurred while loading the PDF.',
-          invalid_file_error: 'Invalid or corrupted PDF file.',
-          missing_file_error: 'Missing PDF file.',
-          unexpected_response_error: 'Unexpected server response.',
-          printing_not_supported: 'Warning: Printing is not fully supported by this browser.',
-          printing_not_ready: 'Warning: The PDF is not fully loaded for printing.',
-          web_fonts_disabled: 'Web fonts are disabled: unable to use embedded PDF fonts.'
-        }
+    if (this.pdfHistory) {
+      this.pdfHistory.pushCurrentPosition();
+      this.pdfHistory.pushPage(pageNumber);
+    }
 
-        function getL10nFallback (key, args) {
-          switch (key) {
-            case 'find_match_count':
-              key = `find_match_count[${args.total === 1 ? 'one' : 'other'}]`
-              break
+    this.pdfViewer.scrollPageIntoView({
+      pageNumber
+    });
+  }
+
+  addLinkAttributes(link, url, newWindow = false) {
+    addLinkAttributes(link, {
+      url,
+      target: newWindow ? LinkTarget.BLANK : this.externalLinkTarget,
+      rel: this.externalLinkRel,
+      enabled: this.externalLinkEnabled
+    });
+  }
+
+  getDestinationHash(dest) {
+    if (typeof dest === "string") {
+      if (dest.length > 0) {
+        return this.getAnchorUrl("#" + escape(dest));
+      }
+    } else if (Array.isArray(dest)) {
+      const str = JSON.stringify(dest);
 
-            case 'find_match_count_limit':
-              key = `find_match_count_limit[${args.limit === 1 ? 'one' : 'other'}]`
-              break
-          }
+      if (str.length > 0) {
+        return this.getAnchorUrl("#" + escape(str));
+      }
+    }
 
-          return DEFAULT_L10N_STRINGS[key] || ''
-        }
+    return this.getAnchorUrl("");
+  }
 
-        function formatL10nValue (text, args) {
-          if (!args) {
-            return text
-          }
+  getAnchorUrl(anchor) {
+    return (this.baseUrl || "") + anchor;
+  }
 
-          return text.replace(/\{\{\s*(\w+)\s*\}\}/g, (all, name) => {
-            return name in args ? args[name] : '{{' + name + '}}'
-          })
-        }
+  setHash(hash) {
+    if (!this.pdfDocument) {
+      return;
+    }
 
-        const NullL10n = {
-          async getLanguage () {
-            return 'en-us'
-          },
+    let pageNumber, dest;
 
-          async getDirection () {
-            return 'ltr'
-          },
+    if (hash.includes("=")) {
+      const params = (0, _ui_utils.parseQueryString)(hash);
 
-          async get (key, args = null, fallback = getL10nFallback(key, args)) {
-            return formatL10nValue(fallback, args)
-          },
+      if (params.has("search")) {
+        this.eventBus.dispatch("findfromurlhash", {
+          source: this,
+          query: params.get("search").replace(/"/g, ""),
+          phraseSearch: params.get("phrase") === "true"
+        });
+      }
 
-          async translate (element) {}
+      if (params.has("page")) {
+        pageNumber = params.get("page") | 0 || 1;
+      }
 
-        }
-        exports.NullL10n = NullL10n
+      if (params.has("zoom")) {
+        const zoomArgs = params.get("zoom").split(",");
+        const zoomArg = zoomArgs[0];
+        const zoomArgNumber = parseFloat(zoomArg);
 
-        /***/
-      }),
-      /* 4 */
-      /***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
-
-        Object.defineProperty(exports, '__esModule', ({
-          value: true
-        }))
-        exports.SimpleLinkService = exports.PDFLinkService = void 0
-
-        var _ui_utils = __w_pdfjs_require__(5)
-
-        class PDFLinkService {
-          constructor ({
-            eventBus,
-            externalLinkTarget = null,
-            externalLinkRel = null,
-            externalLinkEnabled = true,
-            ignoreDestinationZoom = false
-          } = {}) {
-            this.eventBus = eventBus
-            this.externalLinkTarget = externalLinkTarget
-            this.externalLinkRel = externalLinkRel
-            this.externalLinkEnabled = externalLinkEnabled
-            this._ignoreDestinationZoom = ignoreDestinationZoom
-            this.baseUrl = null
-            this.pdfDocument = null
-            this.pdfViewer = null
-            this.pdfHistory = null
-            this._pagesRefCache = null
+        if (!zoomArg.includes("Fit")) {
+          dest = [null, {
+            name: "XYZ"
+          }, zoomArgs.length > 1 ? zoomArgs[1] | 0 : null, zoomArgs.length > 2 ? zoomArgs[2] | 0 : null, zoomArgNumber ? zoomArgNumber / 100 : zoomArg];
+        } else {
+          if (zoomArg === "Fit" || zoomArg === "FitB") {
+            dest = [null, {
+              name: zoomArg
+            }];
+          } else if (zoomArg === "FitH" || zoomArg === "FitBH" || zoomArg === "FitV" || zoomArg === "FitBV") {
+            dest = [null, {
+              name: zoomArg
+            }, zoomArgs.length > 1 ? zoomArgs[1] | 0 : null];
+          } else if (zoomArg === "FitR") {
+            if (zoomArgs.length !== 5) {
+              console.error('PDFLinkService.setHash: Not enough parameters for "FitR".');
+            } else {
+              dest = [null, {
+                name: zoomArg
+              }, zoomArgs[1] | 0, zoomArgs[2] | 0, zoomArgs[3] | 0, zoomArgs[4] | 0];
+            }
+          } else {
+            console.error(`PDFLinkService.setHash: "${zoomArg}" is not a valid zoom value.`);
           }
+        }
+      }
 
-          setDocument (pdfDocument, baseUrl = null) {
-            this.baseUrl = baseUrl
-            this.pdfDocument = pdfDocument
-            this._pagesRefCache = Object.create(null)
-          }
+      if (dest) {
+        this.pdfViewer.scrollPageIntoView({
+          pageNumber: pageNumber || this.page,
+          destArray: dest,
+          allowNegativeOffset: true
+        });
+      } else if (pageNumber) {
+        this.page = pageNumber;
+      }
 
-          setViewer (pdfViewer) {
-            this.pdfViewer = pdfViewer
-          }
+      if (params.has("pagemode")) {
+        this.eventBus.dispatch("pagemode", {
+          source: this,
+          mode: params.get("pagemode")
+        });
+      }
 
-          setHistory (pdfHistory) {
-            this.pdfHistory = pdfHistory
-          }
+      if (params.has("nameddest")) {
+        this.goToDestination(params.get("nameddest"));
+      }
+    } else {
+      dest = unescape(hash);
 
-          get pagesCount () {
-            return this.pdfDocument ? this.pdfDocument.numPages : 0
-          }
+      try {
+        dest = JSON.parse(dest);
 
-          get page () {
-            return this.pdfViewer.currentPageNumber
-          }
+        if (!Array.isArray(dest)) {
+          dest = dest.toString();
+        }
+      } catch (ex) {}
 
-          set page (value) {
-            this.pdfViewer.currentPageNumber = value
-          }
+      if (typeof dest === "string" || PDFLinkService.#isValidExplicitDestination(dest)) {
+        this.goToDestination(dest);
+        return;
+      }
 
-          get rotation () {
-            return this.pdfViewer.pagesRotation
-          }
+      console.error(`PDFLinkService.setHash: "${unescape(hash)}" is not a valid destination.`);
+    }
+  }
 
-          set rotation (value) {
-            this.pdfViewer.pagesRotation = value
-          }
+  executeNamedAction(action) {
+    switch (action) {
+      case "GoBack":
+        this.pdfHistory?.back();
+        break;
 
-          navigateTo (dest) {
-            console.error('Deprecated method: `navigateTo`, use `goToDestination` instead.')
-            this.goToDestination(dest)
-          }
+      case "GoForward":
+        this.pdfHistory?.forward();
+        break;
 
-          _goToDestinationHelper (rawDest, namedDest = null, explicitDest) {
-            const destRef = explicitDest[0]
-            let pageNumber
+      case "NextPage":
+        this.pdfViewer.nextPage();
+        break;
 
-            if (destRef instanceof Object) {
-              pageNumber = this._cachedPageNumber(destRef)
+      case "PrevPage":
+        this.pdfViewer.previousPage();
+        break;
 
-              if (pageNumber === null) {
-                this.pdfDocument.getPageIndex(destRef).then(pageIndex => {
-                  this.cachePageRef(pageIndex + 1, destRef)
+      case "LastPage":
+        this.page = this.pagesCount;
+        break;
 
-                  this._goToDestinationHelper(rawDest, namedDest, explicitDest)
-                }).catch(() => {
-                  console.error(`PDFLinkService._goToDestinationHelper: "${destRef}" is not ` + `a valid page reference, for dest="${rawDest}".`)
-                })
-                return
-              }
-            } else if (Number.isInteger(destRef)) {
-              pageNumber = destRef + 1
-            } else {
-              console.error(`PDFLinkService._goToDestinationHelper: "${destRef}" is not ` + `a valid destination reference, for dest="${rawDest}".`)
-              return
-            }
+      case "FirstPage":
+        this.page = 1;
+        break;
 
-            if (!pageNumber || pageNumber < 1 || pageNumber > this.pagesCount) {
-              console.error(`PDFLinkService._goToDestinationHelper: "${pageNumber}" is not ` + `a valid page number, for dest="${rawDest}".`)
-              return
-            }
+      default:
+        break;
+    }
 
-            if (this.pdfHistory) {
-              this.pdfHistory.pushCurrentPosition()
-              this.pdfHistory.push({
-                namedDest,
-                explicitDest,
-                pageNumber
-              })
-            }
+    this.eventBus.dispatch("namedaction", {
+      source: this,
+      action
+    });
+  }
 
-            this.pdfViewer.scrollPageIntoView({
-              pageNumber,
-              destArray: explicitDest,
-              ignoreDestinationZoom: this._ignoreDestinationZoom
-            })
-          }
+  cachePageRef(pageNum, pageRef) {
+    if (!pageRef) {
+      return;
+    }
 
-          async goToDestination (dest) {
-            if (!this.pdfDocument) {
-              return
-            }
+    const refStr = pageRef.gen === 0 ? `${pageRef.num}R` : `${pageRef.num}R${pageRef.gen}`;
+    this.#pagesRefCache.set(refStr, pageNum);
+  }
 
-            let namedDest, explicitDest
+  _cachedPageNumber(pageRef) {
+    if (!pageRef) {
+      return null;
+    }
 
-            if (typeof dest === 'string') {
-              namedDest = dest
-              explicitDest = await this.pdfDocument.getDestination(dest)
-            } else {
-              namedDest = null
-              explicitDest = await dest
-            }
+    const refStr = pageRef.gen === 0 ? `${pageRef.num}R` : `${pageRef.num}R${pageRef.gen}`;
+    return this.#pagesRefCache.get(refStr) || null;
+  }
 
-            if (!Array.isArray(explicitDest)) {
-              console.error(`PDFLinkService.goToDestination: "${explicitDest}" is not ` + `a valid destination array, for dest="${dest}".`)
-              return
-            }
+  isPageVisible(pageNumber) {
+    return this.pdfViewer.isPageVisible(pageNumber);
+  }
 
-            this._goToDestinationHelper(dest, namedDest, explicitDest)
-          }
+  isPageCached(pageNumber) {
+    return this.pdfViewer.isPageCached(pageNumber);
+  }
 
-          goToPage (val) {
-            if (!this.pdfDocument) {
-              return
-            }
+  static #isValidExplicitDestination(dest) {
+    if (!Array.isArray(dest)) {
+      return false;
+    }
 
-            const pageNumber = typeof val === 'string' && this.pdfViewer.pageLabelToPageNumber(val) || val | 0
+    const destLength = dest.length;
 
-            if (!(Number.isInteger(pageNumber) && pageNumber > 0 && pageNumber <= this.pagesCount)) {
-              console.error(`PDFLinkService.goToPage: "${val}" is not a valid page.`)
-              return
-            }
+    if (destLength < 2) {
+      return false;
+    }
 
-            if (this.pdfHistory) {
-              this.pdfHistory.pushCurrentPosition()
-              this.pdfHistory.pushPage(pageNumber)
-            }
+    const page = dest[0];
 
-            this.pdfViewer.scrollPageIntoView({
-              pageNumber
-            })
-          }
+    if (!(typeof page === "object" && Number.isInteger(page.num) && Number.isInteger(page.gen)) && !(Number.isInteger(page) && page >= 0)) {
+      return false;
+    }
 
-          getDestinationHash (dest) {
-            if (typeof dest === 'string') {
-              if (dest.length > 0) {
-                return this.getAnchorUrl('#' + escape(dest))
-              }
-            } else if (Array.isArray(dest)) {
-              const str = JSON.stringify(dest)
+    const zoom = dest[1];
 
-              if (str.length > 0) {
-                return this.getAnchorUrl('#' + escape(str))
-              }
-            }
+    if (!(typeof zoom === "object" && typeof zoom.name === "string")) {
+      return false;
+    }
 
-            return this.getAnchorUrl('')
-          }
+    let allowNull = true;
 
-          getAnchorUrl (anchor) {
-            return (this.baseUrl || '') + anchor
-          }
+    switch (zoom.name) {
+      case "XYZ":
+        if (destLength !== 5) {
+          return false;
+        }
 
-          setHash (hash) {
-            if (!this.pdfDocument) {
-              return
-            }
+        break;
 
-            let pageNumber, dest
+      case "Fit":
+      case "FitB":
+        return destLength === 2;
 
-            if (hash.includes('=')) {
-              const params = (0, _ui_utils.parseQueryString)(hash)
+      case "FitH":
+      case "FitBH":
+      case "FitV":
+      case "FitBV":
+        if (destLength !== 3) {
+          return false;
+        }
 
-              if ('search' in params) {
-                this.eventBus.dispatch('findfromurlhash', {
-                  source: this,
-                  query: params.search.replace(/"/g, ''),
-                  phraseSearch: params.phrase === 'true'
-                })
-              }
+        break;
 
-              if ('page' in params) {
-                pageNumber = params.page | 0 || 1
-              }
+      case "FitR":
+        if (destLength !== 6) {
+          return false;
+        }
 
-              if ('zoom' in params) {
-                const zoomArgs = params.zoom.split(',')
-                const zoomArg = zoomArgs[0]
-                const zoomArgNumber = parseFloat(zoomArg)
-
-                if (!zoomArg.includes('Fit')) {
-                  dest = [null, {
-                    name: 'XYZ'
-                  }, zoomArgs.length > 1 ? zoomArgs[1] | 0 : null, zoomArgs.length > 2 ? zoomArgs[2] | 0 : null, zoomArgNumber ? zoomArgNumber / 100 : zoomArg]
-                } else {
-                  if (zoomArg === 'Fit' || zoomArg === 'FitB') {
-                    dest = [null, {
-                      name: zoomArg
-                    }]
-                  } else if (zoomArg === 'FitH' || zoomArg === 'FitBH' || zoomArg === 'FitV' || zoomArg === 'FitBV') {
-                    dest = [null, {
-                      name: zoomArg
-                    }, zoomArgs.length > 1 ? zoomArgs[1] | 0 : null]
-                  } else if (zoomArg === 'FitR') {
-                    if (zoomArgs.length !== 5) {
-                      console.error('PDFLinkService.setHash: Not enough parameters for "FitR".')
-                    } else {
-                      dest = [null, {
-                        name: zoomArg
-                      }, zoomArgs[1] | 0, zoomArgs[2] | 0, zoomArgs[3] | 0, zoomArgs[4] | 0]
-                    }
-                  } else {
-                    console.error(`PDFLinkService.setHash: "${zoomArg}" is not ` + 'a valid zoom value.')
-                  }
-                }
-              }
+        allowNull = false;
+        break;
 
-              if (dest) {
-                this.pdfViewer.scrollPageIntoView({
-                  pageNumber: pageNumber || this.page,
-                  destArray: dest,
-                  allowNegativeOffset: true
-                })
-              } else if (pageNumber) {
-                this.page = pageNumber
-              }
+      default:
+        return false;
+    }
 
-              if ('pagemode' in params) {
-                this.eventBus.dispatch('pagemode', {
-                  source: this,
-                  mode: params.pagemode
-                })
-              }
+    for (let i = 2; i < destLength; i++) {
+      const param = dest[i];
 
-              if ('nameddest' in params) {
-                this.goToDestination(params.nameddest)
-              }
-            } else {
-              dest = unescape(hash)
+      if (!(typeof param === "number" || allowNull && param === null)) {
+        return false;
+      }
+    }
 
-              try {
-                dest = JSON.parse(dest)
+    return true;
+  }
+
+}
+
+exports.PDFLinkService = PDFLinkService;
+
+class SimpleLinkService {
+  constructor() {
+    this.externalLinkEnabled = true;
+  }
+
+  get pagesCount() {
+    return 0;
+  }
+
+  get page() {
+    return 0;
+  }
+
+  set page(value) {}
+
+  get rotation() {
+    return 0;
+  }
+
+  set rotation(value) {}
+
+  async goToDestination(dest) {}
+
+  goToPage(val) {}
+
+  addLinkAttributes(link, url, newWindow = false) {
+    addLinkAttributes(link, {
+      url,
+      enabled: this.externalLinkEnabled
+    });
+  }
+
+  getDestinationHash(dest) {
+    return "#";
+  }
+
+  getAnchorUrl(hash) {
+    return "#";
+  }
+
+  setHash(hash) {}
+
+  executeNamedAction(action) {}
+
+  cachePageRef(pageNum, pageRef) {}
+
+  isPageVisible(pageNumber) {
+    return true;
+  }
+
+  isPageCached(pageNumber) {
+    return true;
+  }
+
+}
+
+exports.SimpleLinkService = SimpleLinkService;
+
+/***/ }),
+/* 6 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.animationStarted = exports.VERTICAL_PADDING = exports.UNKNOWN_SCALE = exports.TextLayerMode = exports.SpreadMode = exports.SidebarView = exports.ScrollMode = exports.SCROLLBAR_PADDING = exports.RenderingStates = exports.RendererType = exports.ProgressBar = exports.PresentationModeState = exports.OutputScale = exports.MIN_SCALE = exports.MAX_SCALE = exports.MAX_AUTO_SCALE = exports.DEFAULT_SCALE_VALUE = exports.DEFAULT_SCALE_DELTA = exports.DEFAULT_SCALE = exports.AutoPrintRegExp = void 0;
+exports.apiPageLayoutToViewerModes = apiPageLayoutToViewerModes;
+exports.apiPageModeToSidebarView = apiPageModeToSidebarView;
+exports.approximateFraction = approximateFraction;
+exports.backtrackBeforeAllVisibleElements = backtrackBeforeAllVisibleElements;
+exports.binarySearchFirstItem = binarySearchFirstItem;
+exports.getActiveOrFocusedElement = getActiveOrFocusedElement;
+exports.getPageSizeInches = getPageSizeInches;
+exports.getVisibleElements = getVisibleElements;
+exports.isPortraitOrientation = isPortraitOrientation;
+exports.isValidRotation = isValidRotation;
+exports.isValidScrollMode = isValidScrollMode;
+exports.isValidSpreadMode = isValidSpreadMode;
+exports.noContextMenuHandler = noContextMenuHandler;
+exports.normalizeWheelEventDelta = normalizeWheelEventDelta;
+exports.normalizeWheelEventDirection = normalizeWheelEventDirection;
+exports.parseQueryString = parseQueryString;
+exports.removeNullCharacters = removeNullCharacters;
+exports.roundToDivide = roundToDivide;
+exports.scrollIntoView = scrollIntoView;
+exports.watchScroll = watchScroll;
+const DEFAULT_SCALE_VALUE = "auto";
+exports.DEFAULT_SCALE_VALUE = DEFAULT_SCALE_VALUE;
+const DEFAULT_SCALE = 1.0;
+exports.DEFAULT_SCALE = DEFAULT_SCALE;
+const DEFAULT_SCALE_DELTA = 1.1;
+exports.DEFAULT_SCALE_DELTA = DEFAULT_SCALE_DELTA;
+const MIN_SCALE = 0.1;
+exports.MIN_SCALE = MIN_SCALE;
+const MAX_SCALE = 10.0;
+exports.MAX_SCALE = MAX_SCALE;
+const UNKNOWN_SCALE = 0;
+exports.UNKNOWN_SCALE = UNKNOWN_SCALE;
+const MAX_AUTO_SCALE = 1.25;
+exports.MAX_AUTO_SCALE = MAX_AUTO_SCALE;
+const SCROLLBAR_PADDING = 40;
+exports.SCROLLBAR_PADDING = SCROLLBAR_PADDING;
+const VERTICAL_PADDING = 5;
+exports.VERTICAL_PADDING = VERTICAL_PADDING;
+const RenderingStates = {
+  INITIAL: 0,
+  RUNNING: 1,
+  PAUSED: 2,
+  FINISHED: 3
+};
+exports.RenderingStates = RenderingStates;
+const PresentationModeState = {
+  UNKNOWN: 0,
+  NORMAL: 1,
+  CHANGING: 2,
+  FULLSCREEN: 3
+};
+exports.PresentationModeState = PresentationModeState;
+const SidebarView = {
+  UNKNOWN: -1,
+  NONE: 0,
+  THUMBS: 1,
+  OUTLINE: 2,
+  ATTACHMENTS: 3,
+  LAYERS: 4
+};
+exports.SidebarView = SidebarView;
+const RendererType = {
+  CANVAS: "canvas",
+  SVG: "svg"
+};
+exports.RendererType = RendererType;
+const TextLayerMode = {
+  DISABLE: 0,
+  ENABLE: 1,
+  ENABLE_ENHANCE: 2
+};
+exports.TextLayerMode = TextLayerMode;
+const ScrollMode = {
+  UNKNOWN: -1,
+  VERTICAL: 0,
+  HORIZONTAL: 1,
+  WRAPPED: 2,
+  PAGE: 3
+};
+exports.ScrollMode = ScrollMode;
+const SpreadMode = {
+  UNKNOWN: -1,
+  NONE: 0,
+  ODD: 1,
+  EVEN: 2
+};
+exports.SpreadMode = SpreadMode;
+const AutoPrintRegExp = /\bprint\s*\(/;
+exports.AutoPrintRegExp = AutoPrintRegExp;
+
+class OutputScale {
+  constructor() {
+    const pixelRatio = window.devicePixelRatio || 1;
+    this.sx = pixelRatio;
+    this.sy = pixelRatio;
+  }
+
+  get scaled() {
+    return this.sx !== 1 || this.sy !== 1;
+  }
+
+}
+
+exports.OutputScale = OutputScale;
+
+function scrollIntoView(element, spot, scrollMatches = false) {
+  let parent = element.offsetParent;
+
+  if (!parent) {
+    console.error("offsetParent is not set -- cannot scroll");
+    return;
+  }
+
+  let offsetY = element.offsetTop + element.clientTop;
+  let offsetX = element.offsetLeft + element.clientLeft;
+
+  while (parent.clientHeight === parent.scrollHeight && parent.clientWidth === parent.scrollWidth || scrollMatches && (parent.classList.contains("markedContent") || getComputedStyle(parent).overflow === "hidden")) {
+    offsetY += parent.offsetTop;
+    offsetX += parent.offsetLeft;
+    parent = parent.offsetParent;
+
+    if (!parent) {
+      return;
+    }
+  }
 
-                if (!Array.isArray(dest)) {
-                  dest = dest.toString()
-                }
-              } catch (ex) {}
+  if (spot) {
+    if (spot.top !== undefined) {
+      offsetY += spot.top;
+    }
 
-              if (typeof dest === 'string' || isValidExplicitDestination(dest)) {
-                this.goToDestination(dest)
-                return
-              }
+    if (spot.left !== undefined) {
+      offsetX += spot.left;
+      parent.scrollLeft = offsetX;
+    }
+  }
 
-              console.error(`PDFLinkService.setHash: "${unescape(hash)}" is not ` + 'a valid destination.')
-            }
-          }
+  if (parent && parent.classList.contains('pdfViewer')) {
+    parent = parent.parentElement
+  }
 
-          executeNamedAction (action) {
-            switch (action) {
-              case 'GoBack':
-                if (this.pdfHistory) {
-                  this.pdfHistory.back()
-                }
+  parent.scrollTop = offsetY;
+}
 
-                break
+function watchScroll(viewAreaElement, callback) {
+  const debounceScroll = function (evt) {
+    if (rAF) {
+      return;
+    }
 
-              case 'GoForward':
-                if (this.pdfHistory) {
-                  this.pdfHistory.forward()
-                }
+    rAF = window.requestAnimationFrame(function viewAreaElementScrolled() {
+      rAF = null;
+      const currentX = viewAreaElement.scrollLeft;
+      const lastX = state.lastX;
 
-                break
+      if (currentX !== lastX) {
+        state.right = currentX > lastX;
+      }
 
-              case 'NextPage':
-                this.pdfViewer.nextPage()
-                break
+      state.lastX = currentX;
+      const currentY = viewAreaElement.scrollTop;
+      const lastY = state.lastY;
 
-              case 'PrevPage':
-                this.pdfViewer.previousPage()
-                break
+      if (currentY !== lastY) {
+        state.down = currentY > lastY;
+      }
 
-              case 'LastPage':
-                this.page = this.pagesCount
-                break
+      state.lastY = currentY;
+      callback(state);
+    });
+  };
+
+  const state = {
+    right: true,
+    down: true,
+    lastX: viewAreaElement.scrollLeft,
+    lastY: viewAreaElement.scrollTop,
+    _eventHandler: debounceScroll
+  };
+  let rAF = null;
+  viewAreaElement.addEventListener("scroll", debounceScroll, true);
+  return state;
+}
+
+function parseQueryString(query) {
+  const params = new Map();
+
+  for (const [key, value] of new URLSearchParams(query)) {
+    params.set(key.toLowerCase(), value);
+  }
+
+  return params;
+}
+
+const NullCharactersRegExp = /\x00/g;
+const InvisibleCharactersRegExp = /[\x01-\x1F]/g;
+
+function removeNullCharacters(str, replaceInvisible = false) {
+  if (typeof str !== "string") {
+    console.error(`The argument must be a string.`);
+    return str;
+  }
+
+  if (replaceInvisible) {
+    str = str.replace(InvisibleCharactersRegExp, " ");
+  }
+
+  return str.replace(NullCharactersRegExp, "");
+}
+
+function binarySearchFirstItem(items, condition, start = 0) {
+  let minIndex = start;
+  let maxIndex = items.length - 1;
+
+  if (maxIndex < 0 || !condition(items[maxIndex])) {
+    return items.length;
+  }
+
+  if (condition(items[minIndex])) {
+    return minIndex;
+  }
+
+  while (minIndex < maxIndex) {
+    const currentIndex = minIndex + maxIndex >> 1;
+    const currentItem = items[currentIndex];
+
+    if (condition(currentItem)) {
+      maxIndex = currentIndex;
+    } else {
+      minIndex = currentIndex + 1;
+    }
+  }
 
-              case 'FirstPage':
-                this.page = 1
-                break
+  return minIndex;
+}
 
-              default:
-                break
-            }
+function approximateFraction(x) {
+  if (Math.floor(x) === x) {
+    return [x, 1];
+  }
 
-            this.eventBus.dispatch('namedaction', {
-              source: this,
-              action
-            })
-          }
+  const xinv = 1 / x;
+  const limit = 8;
 
-          cachePageRef (pageNum, pageRef) {
-            if (!pageRef) {
-              return
-            }
+  if (xinv > limit) {
+    return [1, limit];
+  } else if (Math.floor(xinv) === xinv) {
+    return [1, xinv];
+  }
 
-            const refStr = pageRef.gen === 0 ? `${pageRef.num}R` : `${pageRef.num}R${pageRef.gen}`
-            this._pagesRefCache[refStr] = pageNum
-          }
+  const x_ = x > 1 ? xinv : x;
+  let a = 0,
+      b = 1,
+      c = 1,
+      d = 1;
 
-          _cachedPageNumber (pageRef) {
-            const refStr = pageRef.gen === 0 ? `${pageRef.num}R` : `${pageRef.num}R${pageRef.gen}`
-            return this._pagesRefCache?.[refStr] || null
-          }
+  while (true) {
+    const p = a + c,
+          q = b + d;
 
-          isPageVisible (pageNumber) {
-            return this.pdfViewer.isPageVisible(pageNumber)
-          }
+    if (q > limit) {
+      break;
+    }
 
-          isPageCached (pageNumber) {
-            return this.pdfViewer.isPageCached(pageNumber)
-          }
+    if (x_ <= p / q) {
+      c = p;
+      d = q;
+    } else {
+      a = p;
+      b = q;
+    }
+  }
+
+  let result;
+
+  if (x_ - a / b < c / d - x_) {
+    result = x_ === x ? [a, b] : [b, a];
+  } else {
+    result = x_ === x ? [c, d] : [d, c];
+  }
+
+  return result;
+}
+
+function roundToDivide(x, div) {
+  const r = x % div;
+  return r === 0 ? x : Math.round(x - r + div);
+}
+
+function getPageSizeInches({
+  view,
+  userUnit,
+  rotate
+}) {
+  const [x1, y1, x2, y2] = view;
+  const changeOrientation = rotate % 180 !== 0;
+  const width = (x2 - x1) / 72 * userUnit;
+  const height = (y2 - y1) / 72 * userUnit;
+  return {
+    width: changeOrientation ? height : width,
+    height: changeOrientation ? width : height
+  };
+}
+
+function backtrackBeforeAllVisibleElements(index, views, top) {
+  if (index < 2) {
+    return index;
+  }
+
+  let elt = views[index].div;
+  let pageTop = elt.offsetTop + elt.clientTop;
+
+  if (pageTop >= top) {
+    elt = views[index - 1].div;
+    pageTop = elt.offsetTop + elt.clientTop;
+  }
+
+  for (let i = index - 2; i >= 0; --i) {
+    elt = views[i].div;
+
+    if (elt.offsetTop + elt.clientTop + elt.clientHeight <= pageTop) {
+      break;
+    }
 
-        }
+    index = i;
+  }
+
+  return index;
+}
+
+function getVisibleElements({
+  scrollEl,
+  views,
+  sortByVisibility = false,
+  horizontal = false,
+  rtl = false
+}) {
+  const top = scrollEl.scrollTop,
+        bottom = top + scrollEl.clientHeight;
+  const left = scrollEl.scrollLeft,
+        right = left + scrollEl.clientWidth;
+
+  function isElementBottomAfterViewTop(view) {
+    const element = view.div;
+    const elementBottom = element.offsetTop + element.clientTop + element.clientHeight;
+    return elementBottom > top;
+  }
+
+  function isElementNextAfterViewHorizontally(view) {
+    const element = view.div;
+    const elementLeft = element.offsetLeft + element.clientLeft;
+    const elementRight = elementLeft + element.clientWidth;
+    return rtl ? elementLeft < right : elementRight > left;
+  }
+
+  const visible = [],
+        ids = new Set(),
+        numViews = views.length;
+  let firstVisibleElementInd = binarySearchFirstItem(views, horizontal ? isElementNextAfterViewHorizontally : isElementBottomAfterViewTop);
+
+  if (firstVisibleElementInd > 0 && firstVisibleElementInd < numViews && !horizontal) {
+    firstVisibleElementInd = backtrackBeforeAllVisibleElements(firstVisibleElementInd, views, top);
+  }
+
+  let lastEdge = horizontal ? right : -1;
+
+  for (let i = firstVisibleElementInd; i < numViews; i++) {
+    const view = views[i],
+          element = view.div;
+    const currentWidth = element.offsetLeft + element.clientLeft;
+    const currentHeight = element.offsetTop + element.clientTop;
+    const viewWidth = element.clientWidth,
+          viewHeight = element.clientHeight;
+    const viewRight = currentWidth + viewWidth;
+    const viewBottom = currentHeight + viewHeight;
+
+    if (lastEdge === -1) {
+      if (viewBottom >= bottom) {
+        lastEdge = viewBottom;
+      }
+    } else if ((horizontal ? currentWidth : currentHeight) > lastEdge) {
+      break;
+    }
 
-        exports.PDFLinkService = PDFLinkService
+    if (viewBottom <= top || currentHeight >= bottom || viewRight <= left || currentWidth >= right) {
+      continue;
+    }
 
-        function isValidExplicitDestination (dest) {
-          if (!Array.isArray(dest)) {
-            return false
-          }
+    const hiddenHeight = Math.max(0, top - currentHeight) + Math.max(0, viewBottom - bottom);
+    const hiddenWidth = Math.max(0, left - currentWidth) + Math.max(0, viewRight - right);
+    const fractionHeight = (viewHeight - hiddenHeight) / viewHeight,
+          fractionWidth = (viewWidth - hiddenWidth) / viewWidth;
+    const percent = fractionHeight * fractionWidth * 100 | 0;
+    visible.push({
+      id: view.id,
+      x: currentWidth,
+      y: currentHeight,
+      view,
+      percent,
+      widthPercent: fractionWidth * 100 | 0
+    });
+    ids.add(view.id);
+  }
+
+  const first = visible[0],
+        last = visible[visible.length - 1];
+
+  if (sortByVisibility) {
+    visible.sort(function (a, b) {
+      const pc = a.percent - b.percent;
+
+      if (Math.abs(pc) > 0.001) {
+        return -pc;
+      }
 
-          const destLength = dest.length
+      return a.id - b.id;
+    });
+  }
+
+  return {
+    first,
+    last,
+    views: visible,
+    ids
+  };
+}
+
+function noContextMenuHandler(evt) {
+  evt.preventDefault();
+}
+
+function normalizeWheelEventDirection(evt) {
+  let delta = Math.hypot(evt.deltaX, evt.deltaY);
+  const angle = Math.atan2(evt.deltaY, evt.deltaX);
+
+  if (-0.25 * Math.PI < angle && angle < 0.75 * Math.PI) {
+    delta = -delta;
+  }
+
+  return delta;
+}
+
+function normalizeWheelEventDelta(evt) {
+  let delta = normalizeWheelEventDirection(evt);
+  const MOUSE_DOM_DELTA_PIXEL_MODE = 0;
+  const MOUSE_DOM_DELTA_LINE_MODE = 1;
+  const MOUSE_PIXELS_PER_LINE = 30;
+  const MOUSE_LINES_PER_PAGE = 30;
+
+  if (evt.deltaMode === MOUSE_DOM_DELTA_PIXEL_MODE) {
+    delta /= MOUSE_PIXELS_PER_LINE * MOUSE_LINES_PER_PAGE;
+  } else if (evt.deltaMode === MOUSE_DOM_DELTA_LINE_MODE) {
+    delta /= MOUSE_LINES_PER_PAGE;
+  }
+
+  return delta;
+}
+
+function isValidRotation(angle) {
+  return Number.isInteger(angle) && angle % 90 === 0;
+}
+
+function isValidScrollMode(mode) {
+  return Number.isInteger(mode) && Object.values(ScrollMode).includes(mode) && mode !== ScrollMode.UNKNOWN;
+}
+
+function isValidSpreadMode(mode) {
+  return Number.isInteger(mode) && Object.values(SpreadMode).includes(mode) && mode !== SpreadMode.UNKNOWN;
+}
+
+function isPortraitOrientation(size) {
+  return size.width <= size.height;
+}
+
+const animationStarted = new Promise(function (resolve) {
+  window.requestAnimationFrame(resolve);
+});
+exports.animationStarted = animationStarted;
+
+function clamp(v, min, max) {
+  return Math.min(Math.max(v, min), max);
+}
+
+class ProgressBar {
+  constructor(id) {
+    if (arguments.length > 1) {
+      throw new Error("ProgressBar no longer accepts any additional options, " + "please use CSS rules to modify its appearance instead.");
+    }
 
-          if (destLength < 2) {
-            return false
-          }
+    this.visible = true;
+    this.div = document.querySelector(id + " .progress");
+    this.bar = this.div.parentNode;
+    this.percent = 0;
+  }
 
-          const page = dest[0]
+  #updateBar() {
+    if (this._indeterminate) {
+      this.div.classList.add("indeterminate");
+      return;
+    }
 
-          if (!(typeof page === 'object' && Number.isInteger(page.num) && Number.isInteger(page.gen)) && !(Number.isInteger(page) && page >= 0)) {
-            return false
-          }
+    this.div.classList.remove("indeterminate");
+    const doc = document.documentElement;
+    doc.style.setProperty("--progressBar-percent", `${this._percent}%`);
+  }
 
-          const zoom = dest[1]
+  get percent() {
+    return this._percent;
+  }
 
-          if (!(typeof zoom === 'object' && typeof zoom.name === 'string')) {
-            return false
-          }
+  set percent(val) {
+    this._indeterminate = isNaN(val);
+    this._percent = clamp(val, 0, 100);
+    this.#updateBar();
+  }
 
-          let allowNull = true
+  setWidth(viewer) {
+    if (!viewer) {
+      return;
+    }
 
-          switch (zoom.name) {
-            case 'XYZ':
-              if (destLength !== 5) {
-                return false
-              }
+    const container = viewer.parentNode;
+    const scrollbarWidth = container.offsetWidth - viewer.offsetWidth;
 
-              break
+    if (scrollbarWidth > 0) {
+      const doc = document.documentElement;
+      doc.style.setProperty("--progressBar-end-offset", `${scrollbarWidth}px`);
+    }
+  }
 
-            case 'Fit':
-            case 'FitB':
-              return destLength === 2
+  hide() {
+    if (!this.visible) {
+      return;
+    }
 
-            case 'FitH':
-            case 'FitBH':
-            case 'FitV':
-            case 'FitBV':
-              if (destLength !== 3) {
-                return false
-              }
+    this.visible = false;
+    this.bar.classList.add("hidden");
+  }
 
-              break
+  show() {
+    if (this.visible) {
+      return;
+    }
 
-            case 'FitR':
-              if (destLength !== 6) {
-                return false
-              }
+    this.visible = true;
+    this.bar.classList.remove("hidden");
+  }
+
+}
+
+exports.ProgressBar = ProgressBar;
+
+function getActiveOrFocusedElement() {
+  let curRoot = document;
+  let curActiveOrFocused = curRoot.activeElement || curRoot.querySelector(":focus");
+
+  while (curActiveOrFocused?.shadowRoot) {
+    curRoot = curActiveOrFocused.shadowRoot;
+    curActiveOrFocused = curRoot.activeElement || curRoot.querySelector(":focus");
+  }
+
+  return curActiveOrFocused;
+}
+
+function apiPageLayoutToViewerModes(layout) {
+  let scrollMode = ScrollMode.VERTICAL,
+      spreadMode = SpreadMode.NONE;
+
+  switch (layout) {
+    case "SinglePage":
+      scrollMode = ScrollMode.PAGE;
+      break;
+
+    case "OneColumn":
+      break;
+
+    case "TwoPageLeft":
+      scrollMode = ScrollMode.PAGE;
+
+    case "TwoColumnLeft":
+      spreadMode = SpreadMode.ODD;
+      break;
+
+    case "TwoPageRight":
+      scrollMode = ScrollMode.PAGE;
+
+    case "TwoColumnRight":
+      spreadMode = SpreadMode.EVEN;
+      break;
+  }
+
+  return {
+    scrollMode,
+    spreadMode
+  };
+}
+
+function apiPageModeToSidebarView(mode) {
+  switch (mode) {
+    case "UseNone":
+      return SidebarView.NONE;
+
+    case "UseThumbs":
+      return SidebarView.THUMBS;
+
+    case "UseOutlines":
+      return SidebarView.OUTLINE;
+
+    case "UseAttachments":
+      return SidebarView.ATTACHMENTS;
+
+    case "UseOC":
+      return SidebarView.LAYERS;
+  }
+
+  return SidebarView.NONE;
+}
+
+/***/ }),
+/* 7 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.StructTreeLayerBuilder = void 0;
+const PDF_ROLE_TO_HTML_ROLE = {
+  Document: null,
+  DocumentFragment: null,
+  Part: "group",
+  Sect: "group",
+  Div: "group",
+  Aside: "note",
+  NonStruct: "none",
+  P: null,
+  H: "heading",
+  Title: null,
+  FENote: "note",
+  Sub: "group",
+  Lbl: null,
+  Span: null,
+  Em: null,
+  Strong: null,
+  Link: "link",
+  Annot: "note",
+  Form: "form",
+  Ruby: null,
+  RB: null,
+  RT: null,
+  RP: null,
+  Warichu: null,
+  WT: null,
+  WP: null,
+  L: "list",
+  LI: "listitem",
+  LBody: null,
+  Table: "table",
+  TR: "row",
+  TH: "columnheader",
+  TD: "cell",
+  THead: "columnheader",
+  TBody: null,
+  TFoot: null,
+  Caption: null,
+  Figure: "figure",
+  Formula: null,
+  Artifact: null
+};
+const HEADING_PATTERN = /^H(\d+)$/;
+
+class StructTreeLayerBuilder {
+  constructor({
+    pdfPage
+  }) {
+    this.pdfPage = pdfPage;
+  }
+
+  render(structTree) {
+    return this._walk(structTree);
+  }
+
+  _setAttributes(structElement, htmlElement) {
+    if (structElement.alt !== undefined) {
+      htmlElement.setAttribute("aria-label", structElement.alt);
+    }
 
-              allowNull = false
-              break
+    if (structElement.id !== undefined) {
+      htmlElement.setAttribute("aria-owns", structElement.id);
+    }
 
-            default:
-              return false
-          }
+    if (structElement.lang !== undefined) {
+      htmlElement.setAttribute("lang", structElement.lang);
+    }
+  }
 
-          for (let i = 2; i < destLength; i++) {
-            const param = dest[i]
+  _walk(node) {
+    if (!node) {
+      return null;
+    }
 
-            if (!(typeof param === 'number' || allowNull && param === null)) {
-              return false
-            }
-          }
+    const element = document.createElement("span");
 
-          return true
-        }
+    if ("role" in node) {
+      const {
+        role
+      } = node;
+      const match = role.match(HEADING_PATTERN);
 
-        class SimpleLinkService {
-          constructor () {
-            this.externalLinkTarget = null
-            this.externalLinkRel = null
-            this.externalLinkEnabled = true
-            this._ignoreDestinationZoom = false
-          }
+      if (match) {
+        element.setAttribute("role", "heading");
+        element.setAttribute("aria-level", match[1]);
+      } else if (PDF_ROLE_TO_HTML_ROLE[role]) {
+        element.setAttribute("role", PDF_ROLE_TO_HTML_ROLE[role]);
+      }
+    }
 
-          get pagesCount () {
-            return 0
-          }
+    this._setAttributes(node, element);
 
-          get page () {
-            return 0
-          }
+    if (node.children) {
+      if (node.children.length === 1 && "id" in node.children[0]) {
+        this._setAttributes(node.children[0], element);
+      } else {
+        for (const kid of node.children) {
+          element.appendChild(this._walk(kid));
+        }
+      }
+    }
 
-          set page (value) {}
+    return element;
+  }
 
-          get rotation () {
-            return 0
-          }
+}
 
-          set rotation (value) {}
+exports.StructTreeLayerBuilder = StructTreeLayerBuilder;
 
-          async goToDestination (dest) {}
+/***/ }),
+/* 8 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
 
-          goToPage (val) {}
 
-          getDestinationHash (dest) {
-            return '#'
-          }
 
-          getAnchorUrl (hash) {
-            return '#'
-          }
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.TextLayerBuilder = void 0;
 
-          setHash (hash) {}
+var _pdfjsLib = __w_pdfjs_require__(3);
 
-          executeNamedAction (action) {}
+const EXPAND_DIVS_TIMEOUT = 300;
 
-          cachePageRef (pageNum, pageRef) {}
+class TextLayerBuilder {
+  constructor({
+    textLayerDiv,
+    eventBus,
+    pageIndex,
+    viewport,
+    highlighter = null,
+    enhanceTextSelection = false
+  }) {
+    this.textLayerDiv = textLayerDiv;
+    this.eventBus = eventBus;
+    this.textContent = null;
+    this.textContentItemsStr = [];
+    this.textContentStream = null;
+    this.renderingDone = false;
+    this.pageNumber = pageIndex + 1;
+    this.viewport = viewport;
+    this.textDivs = [];
+    this.textLayerRenderTask = null;
+    this.highlighter = highlighter;
+    this.enhanceTextSelection = enhanceTextSelection;
 
-          isPageVisible (pageNumber) {
-            return true
-          }
+    this._bindMouse();
+  }
 
-          isPageCached (pageNumber) {
-            return true
-          }
+  _finishRendering() {
+    this.renderingDone = true;
 
-        }
+    if (!this.enhanceTextSelection) {
+      const endOfContent = document.createElement("div");
+      endOfContent.className = "endOfContent";
+      this.textLayerDiv.appendChild(endOfContent);
+    }
 
-        exports.SimpleLinkService = SimpleLinkService
+    this.eventBus.dispatch("textlayerrendered", {
+      source: this,
+      pageNumber: this.pageNumber,
+      numTextDivs: this.textDivs.length
+    });
+  }
 
-        /***/
-      }),
-      /* 5 */
-      /***/ ((__unused_webpack_module, exports) => {
-
-        Object.defineProperty(exports, '__esModule', ({
-          value: true
-        }))
-        exports.apiPageLayoutToSpreadMode = apiPageLayoutToSpreadMode
-        exports.apiPageModeToSidebarView = apiPageModeToSidebarView
-        exports.approximateFraction = approximateFraction
-        exports.backtrackBeforeAllVisibleElements = backtrackBeforeAllVisibleElements
-        exports.binarySearchFirstItem = binarySearchFirstItem
-        exports.getActiveOrFocusedElement = getActiveOrFocusedElement
-        exports.getOutputScale = getOutputScale
-        exports.getPageSizeInches = getPageSizeInches
-        exports.getVisibleElements = getVisibleElements
-        exports.isPortraitOrientation = isPortraitOrientation
-        exports.isValidRotation = isValidRotation
-        exports.isValidScrollMode = isValidScrollMode
-        exports.isValidSpreadMode = isValidSpreadMode
-        exports.moveToEndOfArray = moveToEndOfArray
-        exports.noContextMenuHandler = noContextMenuHandler
-        exports.normalizeWheelEventDelta = normalizeWheelEventDelta
-        exports.normalizeWheelEventDirection = normalizeWheelEventDirection
-        exports.parseQueryString = parseQueryString
-        exports.roundToDivide = roundToDivide
-        exports.scrollIntoView = scrollIntoView
-        exports.waitOnEventOrTimeout = waitOnEventOrTimeout
-        exports.watchScroll = watchScroll
-        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
-        const CSS_UNITS = 96.0 / 72.0
-        exports.CSS_UNITS = CSS_UNITS
-        const DEFAULT_SCALE_VALUE = 'auto'
-        exports.DEFAULT_SCALE_VALUE = DEFAULT_SCALE_VALUE
-        const DEFAULT_SCALE = 1.0
-        exports.DEFAULT_SCALE = DEFAULT_SCALE
-        const MIN_SCALE = 0.1
-        exports.MIN_SCALE = MIN_SCALE
-        const MAX_SCALE = 10.0
-        exports.MAX_SCALE = MAX_SCALE
-        const UNKNOWN_SCALE = 0
-        exports.UNKNOWN_SCALE = UNKNOWN_SCALE
-        const MAX_AUTO_SCALE = 1.25
-        exports.MAX_AUTO_SCALE = MAX_AUTO_SCALE
-        const SCROLLBAR_PADDING = 40
-        exports.SCROLLBAR_PADDING = SCROLLBAR_PADDING
-        const VERTICAL_PADDING = 5
-        exports.VERTICAL_PADDING = VERTICAL_PADDING
-        const LOADINGBAR_END_OFFSET_VAR = '--loadingBar-end-offset'
-        const PresentationModeState = {
-          UNKNOWN: 0,
-          NORMAL: 1,
-          CHANGING: 2,
-          FULLSCREEN: 3
-        }
-        exports.PresentationModeState = PresentationModeState
-        const SidebarView = {
-          UNKNOWN: -1,
-          NONE: 0,
-          THUMBS: 1,
-          OUTLINE: 2,
-          ATTACHMENTS: 3,
-          LAYERS: 4
-        }
-        exports.SidebarView = SidebarView
-        const RendererType = {
-          CANVAS: 'canvas',
-          SVG: 'svg'
-        }
-        exports.RendererType = RendererType
-        const TextLayerMode = {
-          DISABLE: 0,
-          ENABLE: 1,
-          ENABLE_ENHANCE: 2
-        }
-        exports.TextLayerMode = TextLayerMode
-        const ScrollMode = {
-          UNKNOWN: -1,
-          VERTICAL: 0,
-          HORIZONTAL: 1,
-          WRAPPED: 2
-        }
-        exports.ScrollMode = ScrollMode
-        const SpreadMode = {
-          UNKNOWN: -1,
-          NONE: 0,
-          ODD: 1,
-          EVEN: 2
-        }
-        exports.SpreadMode = SpreadMode
-        const AutoPrintRegExp = /\bprint\s*\(/
-        exports.AutoPrintRegExp = AutoPrintRegExp
-
-        function getOutputScale (ctx) {
-          const devicePixelRatio = window.devicePixelRatio || 1
-          const backingStoreRatio = ctx.webkitBackingStorePixelRatio || ctx.mozBackingStorePixelRatio || ctx.backingStorePixelRatio || 1
-          const pixelRatio = devicePixelRatio / backingStoreRatio
-          return {
-            sx: pixelRatio,
-            sy: pixelRatio,
-            scaled: pixelRatio !== 1
-          }
+  render(timeout = 0) {
+    if (!(this.textContent || this.textContentStream) || this.renderingDone) {
+      return;
+    }
+
+    this.cancel();
+    this.textDivs.length = 0;
+    this.highlighter?.setTextMapping(this.textDivs, this.textContentItemsStr);
+    const textLayerFrag = document.createDocumentFragment();
+    this.textLayerRenderTask = (0, _pdfjsLib.renderTextLayer)({
+      textContent: this.textContent,
+      textContentStream: this.textContentStream,
+      container: textLayerFrag,
+      viewport: this.viewport,
+      textDivs: this.textDivs,
+      textContentItemsStr: this.textContentItemsStr,
+      timeout,
+      enhanceTextSelection: this.enhanceTextSelection
+    });
+    this.textLayerRenderTask.promise.then(() => {
+      this.textLayerDiv.appendChild(textLayerFrag);
+
+      this._finishRendering();
+
+      this.highlighter?.enable();
+    }, function (reason) {});
+  }
+
+  cancel() {
+    if (this.textLayerRenderTask) {
+      this.textLayerRenderTask.cancel();
+      this.textLayerRenderTask = null;
+    }
+
+    this.highlighter?.disable();
+  }
+
+  setTextContentStream(readableStream) {
+    this.cancel();
+    this.textContentStream = readableStream;
+  }
+
+  setTextContent(textContent) {
+    this.cancel();
+    this.textContent = textContent;
+  }
+
+  _bindMouse() {
+    const div = this.textLayerDiv;
+    let expandDivsTimer = null;
+    div.addEventListener("mousedown", evt => {
+      if (this.enhanceTextSelection && this.textLayerRenderTask) {
+        this.textLayerRenderTask.expandTextDivs(true);
+
+        if (expandDivsTimer) {
+          clearTimeout(expandDivsTimer);
+          expandDivsTimer = null;
         }
 
-        function scrollIntoView (element, spot, skipOverflowHiddenElements = true) {
-          let parent = element.offsetParent
+        return;
+      }
 
-          if (!parent) {
-            console.error('offsetParent is not set -- cannot scroll')
-            return
-          }
+      const end = div.querySelector(".endOfContent");
 
-          let offsetY = element.offsetTop + element.clientTop
-          let offsetX = element.offsetLeft + element.clientLeft
+      if (!end) {
+        return;
+      }
 
-          while (parent.clientHeight === parent.scrollHeight &&
-                 parent.clientWidth === parent.scrollWidth ||
-                 skipOverflowHiddenElements &&
-                 getComputedStyle(parent).overflow === 'hidden') {
-            if (parent.dataset._scaleY) {
-              offsetY /= parent.dataset._scaleY
-              offsetX /= parent.dataset._scaleX
-            }
+      let adjustTop = evt.target !== div;
+      adjustTop = adjustTop && window.getComputedStyle(end).getPropertyValue("-moz-user-select") !== "none";
 
-            offsetY += parent.offsetTop
-            offsetX += parent.offsetLeft
-            parent = parent.offsetParent
+      if (adjustTop) {
+        const divBounds = div.getBoundingClientRect();
+        const r = Math.max(0, (evt.pageY - divBounds.top) / divBounds.height);
+        end.style.top = (r * 100).toFixed(2) + "%";
+      }
 
-            if (!parent) {
-              return
-            }
+      end.classList.add("active");
+    });
+    div.addEventListener("mouseup", () => {
+      if (this.enhanceTextSelection && this.textLayerRenderTask) {
+        expandDivsTimer = setTimeout(() => {
+          if (this.textLayerRenderTask) {
+            this.textLayerRenderTask.expandTextDivs(false);
           }
 
-          if (spot) {
-            if (spot.top !== undefined) {
-              offsetY += spot.top
-            }
+          expandDivsTimer = null;
+        }, EXPAND_DIVS_TIMEOUT);
+        return;
+      }
 
-            if (spot.left !== undefined) {
-              offsetX += spot.left
-              parent.scrollLeft = offsetX
-            }
-          }
+      const end = div.querySelector(".endOfContent");
 
-          if (parent && parent.classList.contains('pdfViewer')) {
-            parent = parent.parentElement
-          }
+      if (!end) {
+        return;
+      }
 
-          parent.scrollTop = offsetY
-        }
+      end.style.top = "";
+      end.classList.remove("active");
+    });
+  }
+
+}
+
+exports.TextLayerBuilder = TextLayerBuilder;
+
+/***/ }),
+/* 9 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.XfaLayerBuilder = void 0;
+
+var _pdfjsLib = __w_pdfjs_require__(3);
+
+class XfaLayerBuilder {
+  constructor({
+    pageDiv,
+    pdfPage,
+    annotationStorage = null,
+    linkService,
+    xfaHtml = null
+  }) {
+    this.pageDiv = pageDiv;
+    this.pdfPage = pdfPage;
+    this.annotationStorage = annotationStorage;
+    this.linkService = linkService;
+    this.xfaHtml = xfaHtml;
+    this.div = null;
+    this._cancelled = false;
+  }
+
+  render(viewport, intent = "display") {
+    if (intent === "print") {
+      const parameters = {
+        viewport: viewport.clone({
+          dontFlip: true
+        }),
+        div: this.div,
+        xfaHtml: this.xfaHtml,
+        annotationStorage: this.annotationStorage,
+        linkService: this.linkService,
+        intent
+      };
+      const div = document.createElement("div");
+      this.pageDiv.appendChild(div);
+      parameters.div = div;
+
+      const result = _pdfjsLib.XfaLayer.render(parameters);
+
+      return Promise.resolve(result);
+    }
 
-        function watchScroll (viewAreaElement, callback) {
-          const debounceScroll = function (evt) {
-            if (rAF) {
-              return
-            }
+    return this.pdfPage.getXfa().then(xfaHtml => {
+      if (this._cancelled || !xfaHtml) {
+        return {
+          textDivs: []
+        };
+      }
 
-            rAF = window.requestAnimationFrame(function viewAreaElementScrolled () {
-              rAF = null
-              const currentX = viewAreaElement.scrollLeft
-              const lastX = state.lastX
+      const parameters = {
+        viewport: viewport.clone({
+          dontFlip: true
+        }),
+        div: this.div,
+        xfaHtml,
+        annotationStorage: this.annotationStorage,
+        linkService: this.linkService,
+        intent
+      };
+
+      if (this.div) {
+        return _pdfjsLib.XfaLayer.update(parameters);
+      }
 
-              if (currentX !== lastX) {
-                state.right = currentX > lastX
-              }
+      this.div = document.createElement("div");
+      this.pageDiv.appendChild(this.div);
+      parameters.div = this.div;
+      return _pdfjsLib.XfaLayer.render(parameters);
+    }).catch(error => {
+      console.error(error);
+    });
+  }
+
+  cancel() {
+    this._cancelled = true;
+  }
+
+  hide() {
+    if (!this.div) {
+      return;
+    }
 
-              state.lastX = currentX
-              const currentY = viewAreaElement.scrollTop
-              const lastY = state.lastY
+    this.div.hidden = true;
+  }
 
-              if (currentY !== lastY) {
-                state.down = currentY > lastY
-              }
+}
 
-              state.lastY = currentY
-              callback(state)
-            })
-          }
+exports.XfaLayerBuilder = XfaLayerBuilder;
 
-          const state = {
-            right: true,
-            down: true,
-            lastX: viewAreaElement.scrollLeft,
-            lastY: viewAreaElement.scrollTop,
-            _eventHandler: debounceScroll
-          }
-          let rAF = null
-          viewAreaElement.addEventListener('scroll', debounceScroll, true)
-          return state
-        }
+/***/ }),
+/* 10 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
 
-        function parseQueryString (query) {
-          const parts = query.split('&')
-          const params = Object.create(null)
 
-          for (let i = 0, ii = parts.length; i < ii; ++i) {
-            const param = parts[i].split('=')
-            const key = param[0].toLowerCase()
-            const value = param.length > 1 ? param[1] : null
-            params[decodeURIComponent(key)] = decodeURIComponent(value)
-          }
 
-          return params
-        }
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDFViewer = exports.PDFSinglePageViewer = void 0;
 
-        function binarySearchFirstItem (items, condition) {
-          let minIndex = 0
-          let maxIndex = items.length - 1
+var _ui_utils = __w_pdfjs_require__(6);
 
-          if (maxIndex < 0 || !condition(items[maxIndex])) {
-            return items.length
-          }
+var _base_viewer = __w_pdfjs_require__(11);
 
-          if (condition(items[minIndex])) {
-            return minIndex
-          }
+class PDFViewer extends _base_viewer.BaseViewer {}
 
-          while (minIndex < maxIndex) {
-            const currentIndex = minIndex + maxIndex >> 1
-            const currentItem = items[currentIndex]
+exports.PDFViewer = PDFViewer;
 
-            if (condition(currentItem)) {
-              maxIndex = currentIndex
-            } else {
-              minIndex = currentIndex + 1
-            }
-          }
+class PDFSinglePageViewer extends _base_viewer.BaseViewer {
+  _resetView() {
+    super._resetView();
 
-          return minIndex
-        }
+    this._scrollMode = _ui_utils.ScrollMode.PAGE;
+    this._spreadMode = _ui_utils.SpreadMode.NONE;
+  }
 
-        function approximateFraction (x) {
-          if (Math.floor(x) === x) {
-            return [x, 1]
-          }
+  set scrollMode(mode) {}
 
-          const xinv = 1 / x
-          const limit = 8
+  _updateScrollMode() {}
 
-          if (xinv > limit) {
-            return [1, limit]
-          } else if (Math.floor(xinv) === xinv) {
-            return [1, xinv]
-          }
+  set spreadMode(mode) {}
 
-          const x_ = x > 1 ? xinv : x
-          let a = 0,
-            b = 1,
-            c = 1,
-            d = 1
+  _updateSpreadMode() {}
 
-          while (true) {
-            const p = a + c,
-              q = b + d
+}
 
-            if (q > limit) {
-              break
-            }
+exports.PDFSinglePageViewer = PDFSinglePageViewer;
 
-            if (x_ <= p / q) {
-              c = p
-              d = q
-            } else {
-              a = p
-              b = q
-            }
-          }
+/***/ }),
+/* 11 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
 
-          let result
 
-          if (x_ - a / b < c / d - x_) {
-            result = x_ === x ? [a, b] : [b, a]
-          } else {
-            result = x_ === x ? [c, d] : [d, c]
-          }
 
-          return result
-        }
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PagesCountLimit = exports.PDFPageViewBuffer = exports.BaseViewer = void 0;
 
-        function roundToDivide (x, div) {
-          const r = x % div
-          return r === 0 ? x : Math.round(x - r + div)
-        }
+var _pdfjsLib = __w_pdfjs_require__(3);
 
-        function getPageSizeInches ({
-          view,
-          userUnit,
-          rotate
-        }) {
-          const [x1, y1, x2, y2] = view
-          const changeOrientation = rotate % 180 !== 0
-          const width = (x2 - x1) / 72 * userUnit
-          const height = (y2 - y1) / 72 * userUnit
-          return {
-            width: changeOrientation ? height : width,
-            height: changeOrientation ? width : height
-          }
-        }
+var _ui_utils = __w_pdfjs_require__(6);
 
-        function backtrackBeforeAllVisibleElements (index, views, top) {
-          if (index < 2) {
-            return index
-          }
+var _annotation_layer_builder = __w_pdfjs_require__(2);
 
-          let elt = views[index].div
-          let pageTop = elt.offsetTop + elt.clientTop
+var _l10n_utils = __w_pdfjs_require__(4);
 
-          if (pageTop >= top) {
-            elt = views[index - 1].div
-            pageTop = elt.offsetTop + elt.clientTop
-          }
+var _pdf_page_view = __w_pdfjs_require__(12);
 
-          for (let i = index - 2; i >= 0; --i) {
-            elt = views[i].div
+var _pdf_rendering_queue = __w_pdfjs_require__(14);
 
-            if (elt.offsetTop + elt.clientTop + elt.clientHeight <= pageTop) {
-              break
-            }
+var _pdf_link_service = __w_pdfjs_require__(5);
 
-            index = i
-          }
+var _struct_tree_layer_builder = __w_pdfjs_require__(7);
 
-          return index
-        }
+var _text_highlighter = __w_pdfjs_require__(15);
 
-        function getVisibleElements ({
-          scrollEl,
-          views,
-          sortByVisibility = false,
-          horizontal = false,
-          rtl = false
-        }) {
-          const top = scrollEl.scrollTop,
-            bottom = top + scrollEl.clientHeight
-          const left = scrollEl.scrollLeft,
-            right = left + scrollEl.clientWidth
-
-          function isElementBottomAfterViewTop (view) {
-            const element = view.div
-            const elementBottom = element.offsetTop + element.clientTop + element.clientHeight
-            return elementBottom > top
-          }
+var _text_layer_builder = __w_pdfjs_require__(8);
 
-          function isElementNextAfterViewHorizontally (view) {
-            const element = view.div
-            const elementLeft = element.offsetLeft + element.clientLeft
-            const elementRight = elementLeft + element.clientWidth
-            return rtl ? elementLeft < right : elementRight > left
-          }
+var _xfa_layer_builder = __w_pdfjs_require__(9);
 
-          const visible = [],
-            numViews = views.length
-          let firstVisibleElementInd = binarySearchFirstItem(views, horizontal ? isElementNextAfterViewHorizontally : isElementBottomAfterViewTop)
+const DEFAULT_CACHE_SIZE = 10;
+const ENABLE_PERMISSIONS_CLASS = "enablePermissions";
+const PagesCountLimit = {
+  FORCE_SCROLL_MODE_PAGE: 15000,
+  FORCE_LAZY_PAGE_INIT: 7500,
+  PAUSE_EAGER_PAGE_INIT: 250
+};
+exports.PagesCountLimit = PagesCountLimit;
 
-          if (firstVisibleElementInd > 0 && firstVisibleElementInd < numViews && !horizontal) {
-            firstVisibleElementInd = backtrackBeforeAllVisibleElements(firstVisibleElementInd, views, top)
-          }
+class PDFPageViewBuffer {
+  #buf = new Set();
+  #size = 0;
 
-          let lastEdge = horizontal ? right : -1
-
-          for (let i = firstVisibleElementInd; i < numViews; i++) {
-            const view = views[i],
-              element = view.div
-            const currentWidth = element.offsetLeft + element.clientLeft
-            const currentHeight = element.offsetTop + element.clientTop
-            const viewWidth = element.clientWidth,
-              viewHeight = element.clientHeight
-            const viewRight = currentWidth + viewWidth
-            const viewBottom = currentHeight + viewHeight
-
-            if (lastEdge === -1) {
-              if (viewBottom >= bottom) {
-                lastEdge = viewBottom
-              }
-            } else if ((horizontal ? currentWidth : currentHeight) > lastEdge) {
-              break
-            }
+  constructor(size) {
+    this.#size = size;
+  }
 
-            if (viewBottom <= top || currentHeight >= bottom || viewRight <= left || currentWidth >= right) {
-              continue
-            }
+  push(view) {
+    const buf = this.#buf;
 
-            const hiddenHeight = Math.max(0, top - currentHeight) + Math.max(0, viewBottom - bottom)
-            const hiddenWidth = Math.max(0, left - currentWidth) + Math.max(0, viewRight - right)
-            const fractionHeight = (viewHeight - hiddenHeight) / viewHeight,
-              fractionWidth = (viewWidth - hiddenWidth) / viewWidth
-            const percent = fractionHeight * fractionWidth * 100 | 0
-            visible.push({
-              id: view.id,
-              x: currentWidth,
-              y: currentHeight,
-              view,
-              percent,
-              widthPercent: fractionWidth * 100 | 0
-            })
-          }
+    if (buf.has(view)) {
+      buf.delete(view);
+    }
 
-          const first = visible[0],
-            last = visible[visible.length - 1]
+    buf.add(view);
 
-          if (sortByVisibility) {
-            visible.sort(function (a, b) {
-              const pc = a.percent - b.percent
+    if (buf.size > this.#size) {
+      this.#destroyFirstView();
+    }
+  }
 
-              if (Math.abs(pc) > 0.001) {
-                return -pc
-              }
+  resize(newSize, idsToKeep = null) {
+    this.#size = newSize;
+    const buf = this.#buf;
 
-              return a.id - b.id
-            })
-          }
+    if (idsToKeep) {
+      const ii = buf.size;
+      let i = 1;
 
-          return {
-            first,
-            last,
-            views: visible
-          }
+      for (const view of buf) {
+        if (idsToKeep.has(view.id)) {
+          buf.delete(view);
+          buf.add(view);
         }
 
-        function noContextMenuHandler (evt) {
-          evt.preventDefault()
+        if (++i > ii) {
+          break;
         }
+      }
+    }
 
-        function normalizeWheelEventDirection (evt) {
-          let delta = Math.hypot(evt.deltaX, evt.deltaY)
-          const angle = Math.atan2(evt.deltaY, evt.deltaX)
+    while (buf.size > this.#size) {
+      this.#destroyFirstView();
+    }
+  }
+
+  has(view) {
+    return this.#buf.has(view);
+  }
+
+  [Symbol.iterator]() {
+    return this.#buf.keys();
+  }
+
+  #destroyFirstView() {
+    const firstView = this.#buf.keys().next().value;
+    firstView?.destroy();
+    this.#buf.delete(firstView);
+  }
+
+}
+
+exports.PDFPageViewBuffer = PDFPageViewBuffer;
+
+class BaseViewer {
+  #buffer = null;
+  #annotationMode = _pdfjsLib.AnnotationMode.ENABLE_FORMS;
+  #previousAnnotationMode = null;
+  #enablePermissions = false;
+  #previousContainerHeight = 0;
+  #scrollModePageState = null;
+  #onVisibilityChange = null;
+
+  constructor(options) {
+    if (this.constructor === BaseViewer) {
+      throw new Error("Cannot initialize BaseViewer.");
+    }
 
-          if (-0.25 * Math.PI < angle && angle < 0.75 * Math.PI) {
-            delta = -delta
-          }
+    const viewerVersion = '2.14.305';
 
-          return delta
-        }
+    if (_pdfjsLib.version !== viewerVersion) {
+      throw new Error(`The API version "${_pdfjsLib.version}" does not match the Viewer version "${viewerVersion}".`);
+    }
 
-        function normalizeWheelEventDelta (evt) {
-          let delta = normalizeWheelEventDirection(evt)
-          const MOUSE_DOM_DELTA_PIXEL_MODE = 0
-          const MOUSE_DOM_DELTA_LINE_MODE = 1
-          const MOUSE_PIXELS_PER_LINE = 30
-          const MOUSE_LINES_PER_PAGE = 30
-
-          if (evt.deltaMode === MOUSE_DOM_DELTA_PIXEL_MODE) {
-            delta /= MOUSE_PIXELS_PER_LINE * MOUSE_LINES_PER_PAGE
-          } else if (evt.deltaMode === MOUSE_DOM_DELTA_LINE_MODE) {
-            delta /= MOUSE_LINES_PER_PAGE
-          }
+    this.container = options.container;
+    this.viewer = options.viewer || options.container.firstElementChild;
 
-          return delta
-        }
+    if (!(this.container?.tagName.toUpperCase() === "DIV" && this.viewer?.tagName.toUpperCase() === "DIV")) {
+      throw new Error("Invalid `container` and/or `viewer` option.");
+    }
 
-        function isValidRotation (angle) {
-          return Number.isInteger(angle) && angle % 90 === 0
-        }
+    if (this.container.offsetParent && getComputedStyle(this.container).position !== "absolute") {
+      throw new Error("The `container` must be absolutely positioned.");
+    }
 
-        function isValidScrollMode (mode) {
-          return Number.isInteger(mode) && Object.values(ScrollMode).includes(mode) && mode !== ScrollMode.UNKNOWN
-        }
-
-        function isValidSpreadMode (mode) {
-          return Number.isInteger(mode) && Object.values(SpreadMode).includes(mode) && mode !== SpreadMode.UNKNOWN
-        }
-
-        function isPortraitOrientation (size) {
-          return size.width <= size.height
-        }
+    this.eventBus = options.eventBus;
+    this.linkService = options.linkService || new _pdf_link_service.SimpleLinkService();
+    this.downloadManager = options.downloadManager || null;
+    this.findController = options.findController || null;
+    this._scriptingManager = options.scriptingManager || null;
+    this.removePageBorders = options.removePageBorders || false;
+    this.textLayerMode = options.textLayerMode ?? _ui_utils.TextLayerMode.ENABLE;
+    this.#annotationMode = options.annotationMode ?? _pdfjsLib.AnnotationMode.ENABLE_FORMS;
+    this.imageResourcesPath = options.imageResourcesPath || "";
+    this.enablePrintAutoRotate = options.enablePrintAutoRotate || false;
+    this.renderer = options.renderer || _ui_utils.RendererType.CANVAS;
+    this.useOnlyCssZoom = options.useOnlyCssZoom || false;
+    this.maxCanvasPixels = options.maxCanvasPixels;
+    this.l10n = options.l10n || _l10n_utils.NullL10n;
+    this.#enablePermissions = options.enablePermissions || false;
+    this.pageColors = options.pageColors || null;
+
+    if (options.pageColors && (!CSS.supports("color", options.pageColors.background) || !CSS.supports("color", options.pageColors.foreground))) {
+      if (options.pageColors.background || options.pageColors.foreground) {
+        console.warn("Ignoring `pageColors`-option, since the browser doesn't support the values used.");
+      }
 
-        const WaitOnType = {
-          EVENT: 'event',
-          TIMEOUT: 'timeout'
-        }
-        exports.WaitOnType = WaitOnType
-
-        function waitOnEventOrTimeout ({
-          target,
-          name,
-          delay = 0
-        }) {
-          return new Promise(function (resolve, reject) {
-            if (typeof target !== 'object' || !(name && typeof name === 'string') || !(Number.isInteger(delay) && delay >= 0)) {
-              throw new Error('waitOnEventOrTimeout - invalid parameters.')
-            }
+      this.pageColors = null;
+    }
 
-            function handler (type) {
-              if (target instanceof EventBus) {
-                target._off(name, eventHandler)
-              } else {
-                target.removeEventListener(name, eventHandler)
-              }
+    this.defaultRenderingQueue = !options.renderingQueue;
 
-              if (timeout) {
-                clearTimeout(timeout)
-              }
+    if (this.defaultRenderingQueue) {
+      this.renderingQueue = new _pdf_rendering_queue.PDFRenderingQueue();
+      this.renderingQueue.setViewer(this);
+    } else {
+      this.renderingQueue = options.renderingQueue;
+    }
 
-              resolve(type)
-            }
+    this._doc = document.documentElement;
+    this.scroll = (0, _ui_utils.watchScroll)(this.container, this._scrollUpdate.bind(this));
+    this.presentationModeState = _ui_utils.PresentationModeState.UNKNOWN;
+    this._onBeforeDraw = this._onAfterDraw = null;
 
-            const eventHandler = handler.bind(null, WaitOnType.EVENT)
+    this._resetView();
 
-            if (target instanceof EventBus) {
-              target._on(name, eventHandler)
-            } else {
-              target.addEventListener(name, eventHandler)
-            }
+    if (this.removePageBorders) {
+      this.viewer.classList.add("removePageBorders");
+    }
 
-            const timeoutHandler = handler.bind(null, WaitOnType.TIMEOUT)
-            const timeout = setTimeout(timeoutHandler, delay)
-          })
-        }
+    this.updateContainerHeightCss();
+    Promise.resolve().then(() => {
+      this.eventBus.dispatch("baseviewerinit", {
+        source: this
+      });
+    });
+  }
+
+  get pagesCount() {
+    return this._pages.length;
+  }
+
+  getPageView(index) {
+    return this._pages[index];
+  }
+
+  get pageViewsReady() {
+    if (!this._pagesCapability.settled) {
+      return false;
+    }
 
-        const animationStarted = new Promise(function (resolve) {
-          window.requestAnimationFrame(resolve)
-        })
-        exports.animationStarted = animationStarted
+    return this._pages.every(function (pageView) {
+      return pageView?.pdfPage;
+    });
+  }
 
-        function dispatchDOMEvent (eventName, args = null) {
-          throw new Error('Not implemented: dispatchDOMEvent')
-        }
+  get renderForms() {
+    return this.#annotationMode === _pdfjsLib.AnnotationMode.ENABLE_FORMS;
+  }
 
-        class EventBus {
-          constructor (options) {
-            this._listeners = Object.create(null)
-          }
+  get enableScripting() {
+    return !!this._scriptingManager;
+  }
 
-          on (eventName, listener, options = null) {
-            this._on(eventName, listener, {
-              external: true,
-              once: options?.once
-            })
-          }
+  get currentPageNumber() {
+    return this._currentPageNumber;
+  }
 
-          off (eventName, listener, options = null) {
-            this._off(eventName, listener, {
-              external: true,
-              once: options?.once
-            })
-          }
+  set currentPageNumber(val) {
+    if (!Number.isInteger(val)) {
+      throw new Error("Invalid page number.");
+    }
 
-          dispatch (eventName) {
-            const eventListeners = this._listeners[eventName]
+    if (!this.pdfDocument) {
+      return;
+    }
 
-            if (!eventListeners || eventListeners.length === 0) {
-              return
-            }
+    if (!this._setCurrentPageNumber(val, true)) {
+      console.error(`currentPageNumber: "${val}" is not a valid page.`);
+    }
+  }
 
-            const args = Array.prototype.slice.call(arguments, 1)
-            let externalListeners
-            eventListeners.slice(0).forEach(({
-              listener,
-              external,
-              once
-            }) => {
-              if (once) {
-                this._off(eventName, listener)
-              }
+  _setCurrentPageNumber(val, resetCurrentPageView = false) {
+    if (this._currentPageNumber === val) {
+      if (resetCurrentPageView) {
+        this.#resetCurrentPageView();
+      }
 
-              if (external) {
-                (externalListeners || (externalListeners = [])).push(listener)
-                return
-              }
+      return true;
+    }
 
-              listener.apply(null, args)
-            })
+    if (!(0 < val && val <= this.pagesCount)) {
+      return false;
+    }
 
-            if (externalListeners) {
-              externalListeners.forEach(listener => {
-                listener.apply(null, args)
-              })
-              externalListeners = null
-            }
-          }
+    const previous = this._currentPageNumber;
+    this._currentPageNumber = val;
+    this.eventBus.dispatch("pagechanging", {
+      source: this,
+      pageNumber: val,
+      pageLabel: this._pageLabels?.[val - 1] ?? null,
+      previous
+    });
+
+    if (resetCurrentPageView) {
+      this.#resetCurrentPageView();
+    }
 
-          _on (eventName, listener, options = null) {
-            var _this$_listeners
+    return true;
+  }
 
-            const eventListeners = (_this$_listeners = this._listeners)[eventName] || (_this$_listeners[eventName] = [])
-            eventListeners.push({
-              listener,
-              external: options?.external === true,
-              once: options?.once === true
-            })
-          }
+  get currentPageLabel() {
+    return this._pageLabels?.[this._currentPageNumber - 1] ?? null;
+  }
 
-          _off (eventName, listener, options = null) {
-            const eventListeners = this._listeners[eventName]
+  set currentPageLabel(val) {
+    if (!this.pdfDocument) {
+      return;
+    }
 
-            if (!eventListeners) {
-              return
-            }
+    let page = val | 0;
 
-            for (let i = 0, ii = eventListeners.length; i < ii; i++) {
-              if (eventListeners[i].listener === listener) {
-                eventListeners.splice(i, 1)
-                return
-              }
-            }
-          }
+    if (this._pageLabels) {
+      const i = this._pageLabels.indexOf(val);
 
-        }
+      if (i >= 0) {
+        page = i + 1;
+      }
+    }
 
-        exports.EventBus = EventBus
+    if (!this._setCurrentPageNumber(page, true)) {
+      console.error(`currentPageLabel: "${val}" is not a valid page.`);
+    }
+  }
 
-        function clamp (v, min, max) {
-          return Math.min(Math.max(v, min), max)
-        }
+  get currentScale() {
+    return this._currentScale !== _ui_utils.UNKNOWN_SCALE ? this._currentScale : _ui_utils.DEFAULT_SCALE;
+  }
 
-        class ProgressBar {
-          constructor (id, {
-            height,
-            width,
-            units
-          } = {}) {
-            this.visible = true
-            this.div = document.querySelector(id + ' .progress')
-            this.bar = this.div.parentNode
-            this.height = height || 100
-            this.width = width || 100
-            this.units = units || '%'
-            this.div.style.height = this.height + this.units
-            this.percent = 0
-          }
+  set currentScale(val) {
+    if (isNaN(val)) {
+      throw new Error("Invalid numeric scale.");
+    }
 
-          _updateBar () {
-            if (this._indeterminate) {
-              this.div.classList.add('indeterminate')
-              this.div.style.width = this.width + this.units
-              return
-            }
+    if (!this.pdfDocument) {
+      return;
+    }
 
-            this.div.classList.remove('indeterminate')
-            const progressSize = this.width * this._percent / 100
-            this.div.style.width = progressSize + this.units
-          }
+    this._setScale(val, false);
+  }
 
-          get percent () {
-            return this._percent
-          }
+  get currentScaleValue() {
+    return this._currentScaleValue;
+  }
 
-          set percent (val) {
-            this._indeterminate = isNaN(val)
-            this._percent = clamp(val, 0, 100)
+  set currentScaleValue(val) {
+    if (!this.pdfDocument) {
+      return;
+    }
 
-            this._updateBar()
-          }
+    this._setScale(val, false);
+  }
 
-          setWidth (viewer) {
-            if (!viewer) {
-              return
-            }
+  get pagesRotation() {
+    return this._pagesRotation;
+  }
 
-            const container = viewer.parentNode
-            const scrollbarWidth = container.offsetWidth - viewer.offsetWidth
+  set pagesRotation(rotation) {
+    if (!(0, _ui_utils.isValidRotation)(rotation)) {
+      throw new Error("Invalid pages rotation angle.");
+    }
 
-            if (scrollbarWidth > 0) {
-              const doc = document.documentElement
-              doc.style.setProperty(LOADINGBAR_END_OFFSET_VAR, `${scrollbarWidth}px`)
-            }
-          }
+    if (!this.pdfDocument) {
+      return;
+    }
 
-          hide () {
-            if (!this.visible) {
-              return
-            }
+    rotation %= 360;
 
-            this.visible = false
-            this.bar.classList.add('hidden')
-          }
+    if (rotation < 0) {
+      rotation += 360;
+    }
 
-          show () {
-            if (this.visible) {
-              return
-            }
+    if (this._pagesRotation === rotation) {
+      return;
+    }
 
-            this.visible = true
-            this.bar.classList.remove('hidden')
-          }
+    this._pagesRotation = rotation;
+    const pageNumber = this._currentPageNumber;
+    const updateArgs = {
+      rotation
+    };
 
-        }
+    for (const pageView of this._pages) {
+      pageView.update(updateArgs);
+    }
 
-        exports.ProgressBar = ProgressBar
+    if (this._currentScaleValue) {
+      this._setScale(this._currentScaleValue, true);
+    }
 
-        function moveToEndOfArray (arr, condition) {
-          const moved = [],
-            len = arr.length
-          let write = 0
+    this.eventBus.dispatch("rotationchanging", {
+      source: this,
+      pagesRotation: rotation,
+      pageNumber
+    });
 
-          for (let read = 0; read < len; ++read) {
-            if (condition(arr[read])) {
-              moved.push(arr[read])
-            } else {
-              arr[write] = arr[read]
-              ++write
-            }
-          }
+    if (this.defaultRenderingQueue) {
+      this.update();
+    }
+  }
 
-          for (let read = 0; write < len; ++read, ++write) {
-            arr[write] = moved[read]
-          }
-        }
+  get firstPagePromise() {
+    return this.pdfDocument ? this._firstPageCapability.promise : null;
+  }
 
-        function getActiveOrFocusedElement () {
-          let curRoot = document
-          let curActiveOrFocused = curRoot.activeElement || curRoot.querySelector(':focus')
+  get onePageRendered() {
+    return this.pdfDocument ? this._onePageRenderedCapability.promise : null;
+  }
 
-          while (curActiveOrFocused?.shadowRoot) {
-            curRoot = curActiveOrFocused.shadowRoot
-            curActiveOrFocused = curRoot.activeElement || curRoot.querySelector(':focus')
-          }
+  get pagesPromise() {
+    return this.pdfDocument ? this._pagesCapability.promise : null;
+  }
 
-          return curActiveOrFocused
-        }
+  #initializePermissions(permissions) {
+    if (!permissions) {
+      return;
+    }
 
-        function apiPageLayoutToSpreadMode (layout) {
-          switch (layout) {
-            case 'SinglePage':
-            case 'OneColumn':
-              return SpreadMode.NONE
+    if (!permissions.includes(_pdfjsLib.PermissionFlag.COPY)) {
+      this.viewer.classList.add(ENABLE_PERMISSIONS_CLASS);
+    }
 
-            case 'TwoColumnLeft':
-            case 'TwoPageLeft':
-              return SpreadMode.ODD
+    if (!permissions.includes(_pdfjsLib.PermissionFlag.MODIFY_ANNOTATIONS) && !permissions.includes(_pdfjsLib.PermissionFlag.FILL_INTERACTIVE_FORMS)) {
+      if (this.#annotationMode === _pdfjsLib.AnnotationMode.ENABLE_FORMS) {
+        this.#previousAnnotationMode = this.#annotationMode;
+        this.#annotationMode = _pdfjsLib.AnnotationMode.ENABLE;
+      }
+    }
+  }
 
-            case 'TwoColumnRight':
-            case 'TwoPageRight':
-              return SpreadMode.EVEN
-          }
+  #onePageRenderedOrForceFetch() {
+    if (document.visibilityState === "hidden" || !this.container.offsetParent || this._getVisiblePages().views.length === 0) {
+      return Promise.resolve();
+    }
 
-          return SpreadMode.NONE
+    const visibilityChangePromise = new Promise(resolve => {
+      this.#onVisibilityChange = () => {
+        if (document.visibilityState !== "hidden") {
+          return;
         }
 
-        function apiPageModeToSidebarView (mode) {
-          switch (mode) {
-            case 'UseNone':
-              return SidebarView.NONE
+        resolve();
+        document.removeEventListener("visibilitychange", this.#onVisibilityChange);
+        this.#onVisibilityChange = null;
+      };
 
-            case 'UseThumbs':
-              return SidebarView.THUMBS
+      document.addEventListener("visibilitychange", this.#onVisibilityChange);
+    });
+    return Promise.race([this._onePageRenderedCapability.promise, visibilityChangePromise]);
+  }
 
-            case 'UseOutlines':
-              return SidebarView.OUTLINE
+  setDocument(pdfDocument) {
+    if (this.pdfDocument) {
+      this.eventBus.dispatch("pagesdestroy", {
+        source: this
+      });
 
-            case 'UseAttachments':
-              return SidebarView.ATTACHMENTS
+      this._cancelRendering();
 
-            case 'UseOC':
-              return SidebarView.LAYERS
-          }
-
-          return SidebarView.NONE
-        }
-
-        /***/
-      }),
-      /* 6 */
-      /***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
-
-        Object.defineProperty(exports, '__esModule', ({
-          value: true
-        }))
-        exports.TextLayerBuilder = exports.DefaultTextLayerFactory = void 0
-
-        var _pdfjsLib = __w_pdfjs_require__(2)
-
-        const EXPAND_DIVS_TIMEOUT = 300
-
-        class TextLayerBuilder {
-          constructor ({
-            textLayerDiv,
-            eventBus,
-            pageIndex,
-            viewport,
-            findController = null,
-            enhanceTextSelection = false
-          }) {
-            this.textLayerDiv = textLayerDiv
-            this.eventBus = eventBus
-            this.textContent = null
-            this.textContentItemsStr = []
-            this.textContentStream = null
-            this.renderingDone = false
-            this.pageIdx = pageIndex
-            this.pageNumber = this.pageIdx + 1
-            this.matches = []
-            this.viewport = viewport
-            this.textDivs = []
-            this.findController = findController
-            this.textLayerRenderTask = null
-            this.enhanceTextSelection = enhanceTextSelection
-            this._onUpdateTextLayerMatches = null
-
-            this._bindMouse()
-          }
-
-          _finishRendering () {
-            this.renderingDone = true
-
-            if (!this.enhanceTextSelection) {
-              const endOfContent = document.createElement('div')
-              endOfContent.className = 'endOfContent'
-              this.textLayerDiv.appendChild(endOfContent)
-            }
+      this._resetView();
 
-            this.eventBus.dispatch('textlayerrendered', {
-              source: this,
-              pageNumber: this.pageNumber,
-              numTextDivs: this.textDivs.length
-            })
-          }
+      if (this.findController) {
+        this.findController.setDocument(null);
+      }
 
-          render (timeout = 0) {
-            if (!(this.textContent || this.textContentStream) || this.renderingDone) {
-              return
-            }
+      if (this._scriptingManager) {
+        this._scriptingManager.setDocument(null);
+      }
+    }
 
-            this.cancel()
-            this.textDivs = []
-            const textLayerFrag = document.createDocumentFragment()
-            this.textLayerRenderTask = (0, _pdfjsLib.renderTextLayer)({
-              textContent: this.textContent,
-              textContentStream: this.textContentStream,
-              container: textLayerFrag,
-              viewport: this.viewport,
-              textDivs: this.textDivs,
-              textContentItemsStr: this.textContentItemsStr,
-              timeout,
-              enhanceTextSelection: this.enhanceTextSelection
-            })
-            this.textLayerRenderTask.promise.then(() => {
-              this.textLayerDiv.appendChild(textLayerFrag)
-
-              this._finishRendering()
-
-              this._updateMatches()
-            }, function (reason) {})
-
-            if (!this._onUpdateTextLayerMatches) {
-              this._onUpdateTextLayerMatches = evt => {
-                if (evt.pageIndex === this.pageIdx || evt.pageIndex === -1) {
-                  this._updateMatches()
-                }
-              }
+    this.pdfDocument = pdfDocument;
 
-              this.eventBus._on('updatetextlayermatches', this._onUpdateTextLayerMatches)
-            }
-          }
+    if (!pdfDocument) {
+      return;
+    }
 
-          cancel () {
-            if (this.textLayerRenderTask) {
-              this.textLayerRenderTask.cancel()
-              this.textLayerRenderTask = null
-            }
+    const isPureXfa = pdfDocument.isPureXfa;
+    const pagesCount = pdfDocument.numPages;
+    const firstPagePromise = pdfDocument.getPage(1);
+    const optionalContentConfigPromise = pdfDocument.getOptionalContentConfig();
+    const permissionsPromise = this.#enablePermissions ? pdfDocument.getPermissions() : Promise.resolve();
+
+    if (pagesCount > PagesCountLimit.FORCE_SCROLL_MODE_PAGE) {
+      console.warn("Forcing PAGE-scrolling for performance reasons, given the length of the document.");
+      const mode = this._scrollMode = _ui_utils.ScrollMode.PAGE;
+      this.eventBus.dispatch("scrollmodechanged", {
+        source: this,
+        mode
+      });
+    }
 
-            if (this._onUpdateTextLayerMatches) {
-              this.eventBus._off('updatetextlayermatches', this._onUpdateTextLayerMatches)
+    this._pagesCapability.promise.then(() => {
+      this.eventBus.dispatch("pagesloaded", {
+        source: this,
+        pagesCount
+      });
+    }, () => {});
 
-              this._onUpdateTextLayerMatches = null
-            }
-          }
+    this._onBeforeDraw = evt => {
+      const pageView = this._pages[evt.pageNumber - 1];
 
-          setTextContentStream (readableStream) {
-            this.cancel()
-            this.textContentStream = readableStream
-          }
+      if (!pageView) {
+        return;
+      }
 
-          setTextContent (textContent) {
-            this.cancel()
-            this.textContent = textContent
-          }
+      this.#buffer.push(pageView);
+    };
 
-          _convertMatches (matches, matchesLength) {
-            if (!matches) {
-              return []
-            }
+    this.eventBus._on("pagerender", this._onBeforeDraw);
 
-            const {
-              textContentItemsStr
-            } = this
-            let i = 0,
-              iIndex = 0
-            const end = textContentItemsStr.length - 1
-            const result = []
+    this._onAfterDraw = evt => {
+      if (evt.cssTransform || this._onePageRenderedCapability.settled) {
+        return;
+      }
 
-            for (let m = 0, mm = matches.length; m < mm; m++) {
-              let matchIdx = matches[m]
+      this._onePageRenderedCapability.resolve({
+        timestamp: evt.timestamp
+      });
 
-              while (i !== end && matchIdx >= iIndex + textContentItemsStr[i].length) {
-                iIndex += textContentItemsStr[i].length
-                i++
-              }
+      this.eventBus._off("pagerendered", this._onAfterDraw);
 
-              if (i === textContentItemsStr.length) {
-                console.error('Could not find a matching mapping')
-              }
+      this._onAfterDraw = null;
 
-              const match = {
-                begin: {
-                  divIdx: i,
-                  offset: matchIdx - iIndex
-                }
-              }
-              matchIdx += matchesLength[m]
+      if (this.#onVisibilityChange) {
+        document.removeEventListener("visibilitychange", this.#onVisibilityChange);
+        this.#onVisibilityChange = null;
+      }
+    };
 
-              while (i !== end && matchIdx > iIndex + textContentItemsStr[i].length) {
-                iIndex += textContentItemsStr[i].length
-                i++
-              }
+    this.eventBus._on("pagerendered", this._onAfterDraw);
 
-              match.end = {
-                divIdx: i,
-                offset: matchIdx - iIndex
-              }
-              result.push(match)
-            }
+    Promise.all([firstPagePromise, permissionsPromise]).then(([firstPdfPage, permissions]) => {
+      if (pdfDocument !== this.pdfDocument) {
+        return;
+      }
 
-            return result
-          }
+      this._firstPageCapability.resolve(firstPdfPage);
+
+      this._optionalContentConfigPromise = optionalContentConfigPromise;
+      this.#initializePermissions(permissions);
+      const viewerElement = this._scrollMode === _ui_utils.ScrollMode.PAGE ? null : this.viewer;
+      const scale = this.currentScale;
+      const viewport = firstPdfPage.getViewport({
+        scale: scale * _pdfjsLib.PixelsPerInch.PDF_TO_CSS_UNITS
+      });
+      const textLayerFactory = this.textLayerMode !== _ui_utils.TextLayerMode.DISABLE && !isPureXfa ? this : null;
+      const annotationLayerFactory = this.#annotationMode !== _pdfjsLib.AnnotationMode.DISABLE ? this : null;
+      const xfaLayerFactory = isPureXfa ? this : null;
+
+      for (let pageNum = 1; pageNum <= pagesCount; ++pageNum) {
+        const pageView = new _pdf_page_view.PDFPageView({
+          container: viewerElement,
+          eventBus: this.eventBus,
+          id: pageNum,
+          scale,
+          defaultViewport: viewport.clone(),
+          optionalContentConfigPromise,
+          renderingQueue: this.renderingQueue,
+          textLayerFactory,
+          textLayerMode: this.textLayerMode,
+          annotationLayerFactory,
+          annotationMode: this.#annotationMode,
+          xfaLayerFactory,
+          textHighlighterFactory: this,
+          structTreeLayerFactory: this,
+          imageResourcesPath: this.imageResourcesPath,
+          renderer: this.renderer,
+          useOnlyCssZoom: this.useOnlyCssZoom,
+          maxCanvasPixels: this.maxCanvasPixels,
+          pageColors: this.pageColors,
+          l10n: this.l10n
+        });
+
+        this._pages.push(pageView);
+      }
 
-          _renderMatches (matches) {
-            if (matches.length === 0) {
-              return
-            }
+      const firstPageView = this._pages[0];
 
-            const {
-              findController,
-              pageIdx,
-              textContentItemsStr,
-              textDivs
-            } = this
-            const isSelectedPage = pageIdx === findController.selected.pageIdx
-            const selectedMatchIdx = findController.selected.matchIdx
-            const highlightAll = findController.state.highlightAll
-            let prevEnd = null
-            const infinity = {
-              divIdx: -1,
-              offset: undefined
-            }
+      if (firstPageView) {
+        firstPageView.setPdfPage(firstPdfPage);
+        this.linkService.cachePageRef(1, firstPdfPage.ref);
+      }
 
-            function beginText (begin, className) {
-              const divIdx = begin.divIdx
-              textDivs[divIdx].textContent = ''
-              appendTextToDiv(divIdx, 0, begin.offset, className)
-            }
+      if (this._scrollMode === _ui_utils.ScrollMode.PAGE) {
+        this.#ensurePageViewVisible();
+      } else if (this._spreadMode !== _ui_utils.SpreadMode.NONE) {
+        this._updateSpreadMode();
+      }
 
-            function appendTextToDiv (divIdx, fromOffset, toOffset, className) {
-              const div = textDivs[divIdx]
-              const content = textContentItemsStr[divIdx].substring(fromOffset, toOffset)
-              const node = document.createTextNode(content)
-
-              if (className) {
-                const span = document.createElement('span')
-                span.className = className
-                span.appendChild(node)
-                div.appendChild(span)
-                return
-              }
+      this.#onePageRenderedOrForceFetch().then(async () => {
+        if (this.findController) {
+          this.findController.setDocument(pdfDocument);
+        }
 
-              div.appendChild(node)
-            }
+        if (this._scriptingManager) {
+          this._scriptingManager.setDocument(pdfDocument);
+        }
 
-            let i0 = selectedMatchIdx,
-              i1 = i0 + 1
+        if (pdfDocument.loadingParams.disableAutoFetch || pagesCount > PagesCountLimit.FORCE_LAZY_PAGE_INIT) {
+          this._pagesCapability.resolve();
 
-            if (highlightAll) {
-              i0 = 0
-              i1 = matches.length
-            } else if (!isSelectedPage) {
-              return
-            }
+          return;
+        }
 
-            for (let i = i0; i < i1; i++) {
-              const match = matches[i]
-              const begin = match.begin
-              const end = match.end
-              const isSelected = isSelectedPage && i === selectedMatchIdx
-              const highlightSuffix = isSelected ? ' selected' : ''
-
-              if (isSelected) {
-                findController.scrollMatchIntoView({
-                  element: textDivs[begin.divIdx],
-                  pageIndex: pageIdx,
-                  matchIndex: selectedMatchIdx
-                })
-              }
+        let getPagesLeft = pagesCount - 1;
 
-              if (!prevEnd || begin.divIdx !== prevEnd.divIdx) {
-                if (prevEnd !== null) {
-                  appendTextToDiv(prevEnd.divIdx, prevEnd.offset, infinity.offset)
-                }
+        if (getPagesLeft <= 0) {
+          this._pagesCapability.resolve();
 
-                beginText(begin)
-              } else {
-                appendTextToDiv(prevEnd.divIdx, prevEnd.offset, begin.offset)
-              }
+          return;
+        }
 
-              if (begin.divIdx === end.divIdx) {
-                appendTextToDiv(begin.divIdx, begin.offset, end.offset, 'highlight' + highlightSuffix)
-              } else {
-                appendTextToDiv(begin.divIdx, begin.offset, infinity.offset, 'highlight begin' + highlightSuffix)
+        for (let pageNum = 2; pageNum <= pagesCount; ++pageNum) {
+          const promise = pdfDocument.getPage(pageNum).then(pdfPage => {
+            const pageView = this._pages[pageNum - 1];
 
-                for (let n0 = begin.divIdx + 1, n1 = end.divIdx; n0 < n1; n0++) {
-                  textDivs[n0].className = 'highlight middle' + highlightSuffix
-                }
+            if (!pageView.pdfPage) {
+              pageView.setPdfPage(pdfPage);
+            }
 
-                beginText(end, 'highlight end' + highlightSuffix)
-              }
+            this.linkService.cachePageRef(pageNum, pdfPage.ref);
 
-              prevEnd = end
+            if (--getPagesLeft === 0) {
+              this._pagesCapability.resolve();
             }
+          }, reason => {
+            console.error(`Unable to get page ${pageNum} to initialize viewer`, reason);
 
-            if (prevEnd) {
-              appendTextToDiv(prevEnd.divIdx, prevEnd.offset, infinity.offset)
+            if (--getPagesLeft === 0) {
+              this._pagesCapability.resolve();
             }
-          }
+          });
 
-          _updateMatches () {
-            if (!this.renderingDone) {
-              return
-            }
+          if (pageNum % PagesCountLimit.PAUSE_EAGER_PAGE_INIT === 0) {
+            await promise;
+          }
+        }
+      });
+      this.eventBus.dispatch("pagesinit", {
+        source: this
+      });
+      pdfDocument.getMetadata().then(({
+        info
+      }) => {
+        if (pdfDocument !== this.pdfDocument) {
+          return;
+        }
 
-            const {
-              findController,
-              matches,
-              pageIdx,
-              textContentItemsStr,
-              textDivs
-            } = this
-            let clearedUntilDivIdx = -1
-
-            for (let i = 0, ii = matches.length; i < ii; i++) {
-              const match = matches[i]
-              const begin = Math.max(clearedUntilDivIdx, match.begin.divIdx)
-
-              for (let n = begin, end = match.end.divIdx; n <= end; n++) {
-                const div = textDivs[n]
-                div.textContent = textContentItemsStr[n]
-                div.className = ''
-              }
+        if (info.Language) {
+          this.viewer.lang = info.Language;
+        }
+      });
 
-              clearedUntilDivIdx = match.end.divIdx + 1
-            }
+      if (this.defaultRenderingQueue) {
+        this.update();
+      }
+    }).catch(reason => {
+      console.error("Unable to initialize viewer", reason);
 
-            if (!findController?.highlightMatches) {
-              return
-            }
+      this._pagesCapability.reject(reason);
+    });
+  }
 
-            const pageMatches = findController.pageMatches[pageIdx] || null
-            const pageMatchesLength = findController.pageMatchesLength[pageIdx] || null
-            this.matches = this._convertMatches(pageMatches, pageMatchesLength)
+  setPageLabels(labels) {
+    if (!this.pdfDocument) {
+      return;
+    }
 
-            this._renderMatches(this.matches)
-          }
+    if (!labels) {
+      this._pageLabels = null;
+    } else if (!(Array.isArray(labels) && this.pdfDocument.numPages === labels.length)) {
+      this._pageLabels = null;
+      console.error(`setPageLabels: Invalid page labels.`);
+    } else {
+      this._pageLabels = labels;
+    }
 
-          _bindMouse () {
-            const div = this.textLayerDiv
-            let expandDivsTimer = null
-            div.addEventListener('mousedown', evt => {
-              if (this.enhanceTextSelection && this.textLayerRenderTask) {
-                this.textLayerRenderTask.expandTextDivs(true)
+    for (let i = 0, ii = this._pages.length; i < ii; i++) {
+      this._pages[i].setPageLabel(this._pageLabels?.[i] ?? null);
+    }
+  }
+
+  _resetView() {
+    this._pages = [];
+    this._currentPageNumber = 1;
+    this._currentScale = _ui_utils.UNKNOWN_SCALE;
+    this._currentScaleValue = null;
+    this._pageLabels = null;
+    this.#buffer = new PDFPageViewBuffer(DEFAULT_CACHE_SIZE);
+    this._location = null;
+    this._pagesRotation = 0;
+    this._optionalContentConfigPromise = null;
+    this._firstPageCapability = (0, _pdfjsLib.createPromiseCapability)();
+    this._onePageRenderedCapability = (0, _pdfjsLib.createPromiseCapability)();
+    this._pagesCapability = (0, _pdfjsLib.createPromiseCapability)();
+    this._scrollMode = _ui_utils.ScrollMode.VERTICAL;
+    this._previousScrollMode = _ui_utils.ScrollMode.UNKNOWN;
+    this._spreadMode = _ui_utils.SpreadMode.NONE;
+    this.#scrollModePageState = {
+      previousPageNumber: 1,
+      scrollDown: true,
+      pages: []
+    };
+
+    if (this._onBeforeDraw) {
+      this.eventBus._off("pagerender", this._onBeforeDraw);
+
+      this._onBeforeDraw = null;
+    }
 
-                if (expandDivsTimer) {
-                  clearTimeout(expandDivsTimer)
-                  expandDivsTimer = null
-                }
+    if (this._onAfterDraw) {
+      this.eventBus._off("pagerendered", this._onAfterDraw);
 
-                return
-              }
+      this._onAfterDraw = null;
+    }
 
-              const end = div.querySelector('.endOfContent')
+    if (this.#onVisibilityChange) {
+      document.removeEventListener("visibilitychange", this.#onVisibilityChange);
+      this.#onVisibilityChange = null;
+    }
 
-              if (!end) {
-                return
-              }
+    this.viewer.textContent = "";
 
-              let adjustTop = evt.target !== div
-              adjustTop = adjustTop && window.getComputedStyle(end).getPropertyValue('-moz-user-select') !== 'none'
+    this._updateScrollMode();
 
-              if (adjustTop) {
-                const divBounds = div.getBoundingClientRect()
-                const r = Math.max(0, (evt.pageY - divBounds.top) / divBounds.height)
-                end.style.top = (r * 100).toFixed(2) + '%'
-              }
+    this.viewer.removeAttribute("lang");
+    this.viewer.classList.remove(ENABLE_PERMISSIONS_CLASS);
 
-              end.classList.add('active')
-            })
-            div.addEventListener('mouseup', () => {
-              if (this.enhanceTextSelection && this.textLayerRenderTask) {
-                expandDivsTimer = setTimeout(() => {
-                  if (this.textLayerRenderTask) {
-                    this.textLayerRenderTask.expandTextDivs(false)
-                  }
-
-                  expandDivsTimer = null
-                }, EXPAND_DIVS_TIMEOUT)
-                return
-              }
+    if (this.#previousAnnotationMode !== null) {
+      this.#annotationMode = this.#previousAnnotationMode;
+      this.#previousAnnotationMode = null;
+    }
+  }
 
-              const end = div.querySelector('.endOfContent')
+  #ensurePageViewVisible() {
+    if (this._scrollMode !== _ui_utils.ScrollMode.PAGE) {
+      throw new Error("#ensurePageViewVisible: Invalid scrollMode value.");
+    }
 
-              if (!end) {
-                return
-              }
+    const pageNumber = this._currentPageNumber,
+          state = this.#scrollModePageState,
+          viewer = this.viewer;
+    viewer.textContent = "";
+    state.pages.length = 0;
+
+    if (this._spreadMode === _ui_utils.SpreadMode.NONE && !this.isInPresentationMode) {
+      const pageView = this._pages[pageNumber - 1];
+      viewer.appendChild(pageView.div);
+      state.pages.push(pageView);
+    } else {
+      const pageIndexSet = new Set(),
+            parity = this._spreadMode - 1;
+
+      if (parity === -1) {
+        pageIndexSet.add(pageNumber - 1);
+      } else if (pageNumber % 2 !== parity) {
+        pageIndexSet.add(pageNumber - 1);
+        pageIndexSet.add(pageNumber);
+      } else {
+        pageIndexSet.add(pageNumber - 2);
+        pageIndexSet.add(pageNumber - 1);
+      }
 
-              end.style.top = ''
-              end.classList.remove('active')
-            })
-          }
+      const spread = document.createElement("div");
+      spread.className = "spread";
 
-        }
+      if (this.isInPresentationMode) {
+        const dummyPage = document.createElement("div");
+        dummyPage.className = "dummyPage";
+        spread.appendChild(dummyPage);
+      }
 
-        exports.TextLayerBuilder = TextLayerBuilder
-
-        class DefaultTextLayerFactory {
-          createTextLayerBuilder (textLayerDiv, pageIndex, viewport, enhanceTextSelection = false, eventBus) {
-            return new TextLayerBuilder({
-              textLayerDiv,
-              pageIndex,
-              viewport,
-              enhanceTextSelection,
-              eventBus
-            })
-          }
+      for (const i of pageIndexSet) {
+        const pageView = this._pages[i];
 
+        if (!pageView) {
+          continue;
         }
 
-        exports.DefaultTextLayerFactory = DefaultTextLayerFactory
+        spread.appendChild(pageView.div);
+        state.pages.push(pageView);
+      }
 
-        /***/
-      }),
-      /* 7 */
-      /***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+      viewer.appendChild(spread);
+    }
 
-        Object.defineProperty(exports, '__esModule', ({
-          value: true
-        }))
-        exports.DownloadManager = void 0
+    state.scrollDown = pageNumber >= state.previousPageNumber;
+    state.previousPageNumber = pageNumber;
+  }
 
-        var _pdfjsLib = __w_pdfjs_require__(2)
+  _scrollUpdate() {
+    if (this.pagesCount === 0) {
+      return;
+    }
 
-        var _viewer_compatibility = __w_pdfjs_require__(8)
+    this.update();
+  }
 
+  #scrollIntoView(pageView, pageSpot = null) {
+    const {
+      div,
+      id
+    } = pageView;
 
+    if (this._scrollMode === _ui_utils.ScrollMode.PAGE) {
+      this._setCurrentPageNumber(id);
 
-        function download (blobUrl, filename) {
-          const a = document.createElement('a')
+      this.#ensurePageViewVisible();
+      this.update();
+    }
 
-          if (!a.click) {
-            throw new Error('DownloadManager: "a.click()" is not supported.')
-          }
+    if (!pageSpot && !this.isInPresentationMode) {
+      const left = div.offsetLeft + div.clientLeft,
+            right = left + div.clientWidth;
+      const {
+        scrollLeft,
+        clientWidth
+      } = this.container;
+
+      if (this._scrollMode === _ui_utils.ScrollMode.HORIZONTAL || left < scrollLeft || right > scrollLeft + clientWidth) {
+        pageSpot = {
+          left: 0,
+          top: 0
+        };
+      }
+    }
 
-          a.href = blobUrl
-          a.target = '_parent'
+    (0, _ui_utils.scrollIntoView)(div, pageSpot);
+  }
 
-          if ('download' in a) {
-            a.download = filename
-          }
+  #isSameScale(newScale) {
+    return newScale === this._currentScale || Math.abs(newScale - this._currentScale) < 1e-15;
+  }
 
-          (document.body || document.documentElement).appendChild(a)
-          a.click()
-          a.remove()
-        }
+  _setScaleUpdatePages(newScale, newValue, noScroll = false, preset = false) {
+    this._currentScaleValue = newValue.toString();
 
-        class DownloadManager {
-          constructor () {
-            this._openBlobUrls = new WeakMap()
-          }
+    if (this.#isSameScale(newScale)) {
+      if (preset) {
+        this.eventBus.dispatch("scalechanging", {
+          source: this,
+          scale: newScale,
+          presetValue: newValue
+        });
+      }
 
-          downloadUrl (url, filename) {
-            if (!(0, _pdfjsLib.createValidAbsoluteUrl)(url, 'http://example.com')) {
-              return
-            }
+      return;
+    }
 
-            download(url + '#pdfjs.action=download', filename)
-          }
+    this._doc.style.setProperty("--zoom-factor", newScale);
 
-          downloadData (data, filename, contentType) {
-            const blobUrl = (0, _pdfjsLib.createObjectURL)(data, contentType, _viewer_compatibility.viewerCompatibilityParams.disableCreateObjectURL)
-            download(blobUrl, filename)
-          }
+    const updateArgs = {
+      scale: newScale
+    };
 
-          openOrDownloadData (element, data, filename) {
-            const isPdfData = (0, _pdfjsLib.isPdfFile)(filename)
-            const contentType = isPdfData ? 'application/pdf' : ''
+    for (const pageView of this._pages) {
+      pageView.update(updateArgs);
+    }
 
-            if (isPdfData && !_viewer_compatibility.viewerCompatibilityParams.disableCreateObjectURL) {
-              let blobUrl = this._openBlobUrls.get(element)
+    this._currentScale = newScale;
 
-              if (!blobUrl) {
-                blobUrl = URL.createObjectURL(new Blob([data], {
-                  type: contentType
-                }))
+    if (!noScroll) {
+      let page = this._currentPageNumber,
+          dest;
 
-                this._openBlobUrls.set(element, blobUrl)
-              }
+      if (this._location && !(this.isInPresentationMode || this.isChangingPresentationMode)) {
+        page = this._location.pageNumber;
+        dest = [null, {
+          name: "XYZ"
+        }, this._location.left, this._location.top, null];
+      }
 
-              let viewerUrl
-              viewerUrl = '?file=' + encodeURIComponent(blobUrl + '#' + filename)
+      this.scrollPageIntoView({
+        pageNumber: page,
+        destArray: dest,
+        allowNegativeOffset: true
+      });
+    }
 
-              try {
-                window.open(viewerUrl)
-                return true
-              } catch (ex) {
-                console.error(`openOrDownloadData: ${ex}`)
-                URL.revokeObjectURL(blobUrl)
+    this.eventBus.dispatch("scalechanging", {
+      source: this,
+      scale: newScale,
+      presetValue: preset ? newValue : undefined
+    });
 
-                this._openBlobUrls.delete(element)
-              }
-            }
+    if (this.defaultRenderingQueue) {
+      this.update();
+    }
 
-            this.downloadData(data, filename, contentType)
-            return false
-          }
+    this.updateContainerHeightCss();
+  }
 
-          download (blob, url, filename, sourceEventType = 'download') {
-            if (_viewer_compatibility.viewerCompatibilityParams.disableCreateObjectURL) {
-              this.downloadUrl(url, filename)
-              return
-            }
+  get _pageWidthScaleFactor() {
+    if (this._spreadMode !== _ui_utils.SpreadMode.NONE && this._scrollMode !== _ui_utils.ScrollMode.HORIZONTAL) {
+      return 2;
+    }
 
-            const blobUrl = URL.createObjectURL(blob)
-            download(blobUrl, filename)
-          }
+    return 1;
+  }
 
-        }
+  _setScale(value, noScroll = false) {
+    let scale = parseFloat(value);
 
-        exports.DownloadManager = DownloadManager
+    if (scale > 0) {
+      this._setScaleUpdatePages(scale, value, noScroll, false);
+    } else {
+      const currentPage = this._pages[this._currentPageNumber - 1];
 
-        /***/
-      }),
-      /* 8 */
-      /***/ ((__unused_webpack_module, exports) => {
-
-        Object.defineProperty(exports, '__esModule', ({
-          value: true
-        }))
-        exports.viewerCompatibilityParams = void 0
-        const compatibilityParams = Object.create(null)
-        {
-          const userAgent = typeof navigator !== 'undefined' && navigator.userAgent || ''
-          const platform = typeof navigator !== 'undefined' && navigator.platform || ''
-          const maxTouchPoints = typeof navigator !== 'undefined' && navigator.maxTouchPoints || 1
-          const isAndroid = /Android/.test(userAgent)
-          const isIOS = /\b(iPad|iPhone|iPod)(?=;)/.test(userAgent) || platform === 'MacIntel' && maxTouchPoints > 1
-          const isIOSChrome = /CriOS/.test(userAgent);
-
-          (function checkOnBlobSupport () {
-            if (isIOSChrome) {
-              compatibilityParams.disableCreateObjectURL = true
-            }
-          })();
+      if (!currentPage) {
+        return;
+      }
 
-          (function checkCanvasSizeLimitation () {
-            if (isIOS || isAndroid) {
-              compatibilityParams.maxCanvasPixels = 5242880
-            }
-          })()
-        }
-        const viewerCompatibilityParams = Object.freeze(compatibilityParams)
-        exports.viewerCompatibilityParams = viewerCompatibilityParams
+      let hPadding = _ui_utils.SCROLLBAR_PADDING,
+          vPadding = _ui_utils.VERTICAL_PADDING;
 
-        /***/
-      }),
-      /* 9 */
-      /***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+      if (this.isInPresentationMode) {
+        hPadding = vPadding = 4;
+      } else if (this.removePageBorders) {
+        hPadding = vPadding = 0;
+      } else if (this._scrollMode === _ui_utils.ScrollMode.HORIZONTAL) {
+        [hPadding, vPadding] = [vPadding, hPadding];
+      }
 
-        Object.defineProperty(exports, '__esModule', ({
-          value: true
-        }))
-        exports.GenericL10n = void 0
+      const pageWidthScale = (this.container.clientWidth - hPadding) / currentPage.width * currentPage.scale / this._pageWidthScaleFactor;
+      const pageHeightScale = (this.container.clientHeight - vPadding) / currentPage.height * currentPage.scale;
 
-        __w_pdfjs_require__(10)
+      switch (value) {
+        case "page-actual":
+          scale = 1;
+          break;
 
-        var _l10n_utils = __w_pdfjs_require__(3)
+        case "page-width":
+          scale = pageWidthScale;
+          break;
 
-        const webL10n = document.webL10n
+        case "page-height":
+          scale = pageHeightScale;
+          break;
 
-        class GenericL10n {
-          constructor (lang) {
-            this._lang = lang
-            this._ready = new Promise((resolve, reject) => {
-              webL10n.setLanguage(lang, () => {
-                resolve(webL10n)
-              })
-            })
-          }
+        case "page-fit":
+          scale = Math.min(pageWidthScale, pageHeightScale);
+          break;
 
-          async getLanguage () {
-            const l10n = await this._ready
-            return l10n.getLanguage()
-          }
+        case "auto":
+          const horizontalScale = (0, _ui_utils.isPortraitOrientation)(currentPage) ? pageWidthScale : Math.min(pageHeightScale, pageWidthScale);
+          scale = Math.min(_ui_utils.MAX_AUTO_SCALE, horizontalScale);
+          break;
 
-          async getDirection () {
-            const l10n = await this._ready
-            return l10n.getDirection()
-          }
+        default:
+          console.error(`_setScale: "${value}" is an unknown zoom value.`);
+          return;
+      }
 
-          async get (key, args = null, fallback = (0, _l10n_utils.getL10nFallback)(key, args)) {
-            const l10n = await this._ready
-            return l10n.get(key, args, fallback)
-          }
+      this._setScaleUpdatePages(scale, value, noScroll, true);
+    }
+  }
 
-          async translate (element) {
-            const l10n = await this._ready
-            return l10n.translate(element)
-          }
+  #resetCurrentPageView() {
+    const pageView = this._pages[this._currentPageNumber - 1];
 
-        }
+    if (this.isInPresentationMode) {
+      this._setScale(this._currentScaleValue, true);
+    }
 
-        exports.GenericL10n = GenericL10n
+    this.#scrollIntoView(pageView);
+  }
 
-        /***/
-      }),
-      /* 10 */
-      /***/ (() => {
-
-        document.webL10n = function (window, document, undefined) {
-          var gL10nData = {}
-          var gTextData = ''
-          var gTextProp = 'textContent'
-          var gLanguage = ''
-          var gMacros = {}
-          var gReadyState = 'loading'
-          var gAsyncResourceLoading = true
-
-          function getL10nResourceLinks () {
-            return document.querySelectorAll('link[type="application/l10n"]')
-          }
+  pageLabelToPageNumber(label) {
+    if (!this._pageLabels) {
+      return null;
+    }
 
-          function getL10nDictionary () {
-            var script = document.querySelector('script[type="application/l10n"]')
-            return script ? JSON.parse(script.innerHTML) : null
-          }
+    const i = this._pageLabels.indexOf(label);
 
-          function getTranslatableChildren (element) {
-            return element ? element.querySelectorAll('*[data-l10n-id]') : []
-          }
+    if (i < 0) {
+      return null;
+    }
 
-          function getL10nAttributes (element) {
-            if (!element) return {}
-            var l10nId = element.getAttribute('data-l10n-id')
-            var l10nArgs = element.getAttribute('data-l10n-args')
-            var args = {}
-
-            if (l10nArgs) {
-              try {
-                args = JSON.parse(l10nArgs)
-              } catch (e) {
-                console.warn('could not parse arguments for #' + l10nId)
-              }
-            }
+    return i + 1;
+  }
+
+  scrollPageIntoView({
+    pageNumber,
+    destArray = null,
+    allowNegativeOffset = false,
+    ignoreDestinationZoom = false
+  }) {
+    if (!this.pdfDocument) {
+      return;
+    }
 
-            return {
-              id: l10nId,
-              args: args
-            }
-          }
+    const pageView = Number.isInteger(pageNumber) && this._pages[pageNumber - 1];
 
-          function xhrLoadText (url, onSuccess, onFailure) {
-            onSuccess = onSuccess || function _onSuccess (data) {}
+    if (!pageView) {
+      console.error(`scrollPageIntoView: "${pageNumber}" is not a valid pageNumber parameter.`);
+      return;
+    }
 
-            onFailure = onFailure || function _onFailure () {}
+    if (this.isInPresentationMode || !destArray) {
+      this._setCurrentPageNumber(pageNumber, true);
 
-            var xhr = new XMLHttpRequest()
-            xhr.open('GET', url, gAsyncResourceLoading)
+      return;
+    }
 
-            if (xhr.overrideMimeType) {
-              xhr.overrideMimeType('text/plain; charset=utf-8')
-            }
+    let x = 0,
+        y = 0;
+    let width = 0,
+        height = 0,
+        widthScale,
+        heightScale;
+    const changeOrientation = pageView.rotation % 180 !== 0;
+    const pageWidth = (changeOrientation ? pageView.height : pageView.width) / pageView.scale / _pdfjsLib.PixelsPerInch.PDF_TO_CSS_UNITS;
+    const pageHeight = (changeOrientation ? pageView.width : pageView.height) / pageView.scale / _pdfjsLib.PixelsPerInch.PDF_TO_CSS_UNITS;
+    let scale = 0;
+
+    switch (destArray[1].name) {
+      case "XYZ":
+        x = destArray[2];
+        y = destArray[3];
+        scale = destArray[4];
+        x = x !== null ? x : 0;
+        y = y !== null ? y : pageHeight;
+        break;
+
+      case "Fit":
+      case "FitB":
+        scale = "page-fit";
+        break;
+
+      case "FitH":
+      case "FitBH":
+        y = destArray[2];
+        scale = "page-width";
+
+        if (y === null && this._location) {
+          x = this._location.left;
+          y = this._location.top;
+        } else if (typeof y !== "number" || y < 0) {
+          y = pageHeight;
+        }
 
-            xhr.onreadystatechange = function () {
-              if (xhr.readyState == 4) {
-                if (xhr.status == 200 || xhr.status === 0) {
-                  onSuccess(xhr.responseText)
-                } else {
-                  onFailure()
-                }
-              }
-            }
+        break;
+
+      case "FitV":
+      case "FitBV":
+        x = destArray[2];
+        width = pageWidth;
+        height = pageHeight;
+        scale = "page-height";
+        break;
+
+      case "FitR":
+        x = destArray[2];
+        y = destArray[3];
+        width = destArray[4] - x;
+        height = destArray[5] - y;
+        const hPadding = this.removePageBorders ? 0 : _ui_utils.SCROLLBAR_PADDING;
+        const vPadding = this.removePageBorders ? 0 : _ui_utils.VERTICAL_PADDING;
+        widthScale = (this.container.clientWidth - hPadding) / width / _pdfjsLib.PixelsPerInch.PDF_TO_CSS_UNITS;
+        heightScale = (this.container.clientHeight - vPadding) / height / _pdfjsLib.PixelsPerInch.PDF_TO_CSS_UNITS;
+        scale = Math.min(Math.abs(widthScale), Math.abs(heightScale));
+        break;
+
+      default:
+        console.error(`scrollPageIntoView: "${destArray[1].name}" is not a valid destination type.`);
+        return;
+    }
 
-            xhr.onerror = onFailure
-            xhr.ontimeout = onFailure
+    if (!ignoreDestinationZoom) {
+      if (scale && scale !== this._currentScale) {
+        this.currentScaleValue = scale;
+      } else if (this._currentScale === _ui_utils.UNKNOWN_SCALE) {
+        this.currentScaleValue = _ui_utils.DEFAULT_SCALE_VALUE;
+      }
+    }
 
-            try {
-              xhr.send(null)
-            } catch (e) {
-              onFailure()
-            }
-          }
+    if (scale === "page-fit" && !destArray[4]) {
+      this.#scrollIntoView(pageView);
+      return;
+    }
 
-          function parseResource (href, lang, successCallback, failureCallback) {
-            var baseURL = href.replace(/[^\/]*$/, '') || './'
+    const boundingRect = [pageView.viewport.convertToViewportPoint(x, y), pageView.viewport.convertToViewportPoint(x + width, y + height)];
+    let left = Math.min(boundingRect[0][0], boundingRect[1][0]);
+    let top = Math.min(boundingRect[0][1], boundingRect[1][1]);
 
-            function evalString (text) {
-              if (text.lastIndexOf('\\') < 0) return text
-              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, '\'')
-            }
+    if (!allowNegativeOffset) {
+      left = Math.max(left, 0);
+      top = Math.max(top, 0);
+    }
 
-            function parseProperties (text, parsedPropertiesCallback) {
-              var dictionary = {}
-              var reBlank = /^\s*|\s*$/
-              var reComment = /^\s*#|^\s*$/
-              var reSection = /^\s*\[(.*)\]\s*$/
-              var reImport = /^\s*@import\s+url\((.*)\)\s*$/i
-              var reSplit = /^([^=\s]*)\s*=\s*(.+)$/
-
-              function parseRawLines (rawText, extendedSyntax, parsedRawLinesCallback) {
-                var entries = rawText.replace(reBlank, '').split(/[\r\n]+/)
-                var currentLang = '*'
-                var genericLang = lang.split('-', 1)[0]
-                var skipLang = false
-                var match = ''
-
-                function nextEntry () {
-                  while (true) {
-                    if (!entries.length) {
-                      parsedRawLinesCallback()
-                      return
-                    }
-
-                    var line = entries.shift()
-                    if (reComment.test(line)) continue
-
-                    if (extendedSyntax) {
-                      match = reSection.exec(line)
-
-                      if (match) {
-                        currentLang = match[1].toLowerCase()
-                        skipLang = currentLang !== '*' && currentLang !== lang && currentLang !== genericLang
-                        continue
-                      } else if (skipLang) {
-                        continue
-                      }
-
-                      match = reImport.exec(line)
-
-                      if (match) {
-                        loadImport(baseURL + match[1], nextEntry)
-                        return
-                      }
-                    }
-
-                    var tmp = line.match(reSplit)
-
-                    if (tmp && tmp.length == 3) {
-                      dictionary[tmp[1]] = evalString(tmp[2])
-                    }
-                  }
-                }
+    this.#scrollIntoView(pageView, {
+      left,
+      top
+    });
+  }
+
+  _updateLocation(firstPage) {
+    const currentScale = this._currentScale;
+    const currentScaleValue = this._currentScaleValue;
+    const normalizedScaleValue = parseFloat(currentScaleValue) === currentScale ? Math.round(currentScale * 10000) / 100 : currentScaleValue;
+    const pageNumber = firstPage.id;
+    const currentPageView = this._pages[pageNumber - 1];
+    const container = this.container;
+    const topLeft = currentPageView.getPagePoint(container.scrollLeft - firstPage.x, container.scrollTop - firstPage.y);
+    const intLeft = Math.round(topLeft[0]);
+    const intTop = Math.round(topLeft[1]);
+    let pdfOpenParams = `#page=${pageNumber}`;
+
+    if (!this.isInPresentationMode) {
+      pdfOpenParams += `&zoom=${normalizedScaleValue},${intLeft},${intTop}`;
+    }
 
-                nextEntry()
-              }
+    this._location = {
+      pageNumber,
+      scale: normalizedScaleValue,
+      top: intTop,
+      left: intLeft,
+      rotation: this._pagesRotation,
+      pdfOpenParams
+    };
+  }
 
-              function loadImport (url, callback) {
-                xhrLoadText(url, function (content) {
-                  parseRawLines(content, false, callback)
-                }, function () {
-                  console.warn(url + ' not found.')
-                  callback()
-                })
-              }
+  update() {
+    const visible = this._getVisiblePages();
 
-              parseRawLines(text, true, function () {
-                parsedPropertiesCallback(dictionary)
-              })
-            }
+    const visiblePages = visible.views,
+          numVisiblePages = visiblePages.length;
 
-            xhrLoadText(href, function (response) {
-              gTextData += response
-              parseProperties(response, function (data) {
-                for (var key in data) {
-                  var id,
-                    prop,
-                    index = key.lastIndexOf('.')
-
-                  if (index > 0) {
-                    id = key.substring(0, index)
-                    prop = key.substring(index + 1)
-                  } else {
-                    id = key
-                    prop = gTextProp
-                  }
-
-                  if (!gL10nData[id]) {
-                    gL10nData[id] = {}
-                  }
-
-                  gL10nData[id][prop] = data[key]
-                }
+    if (numVisiblePages === 0) {
+      return;
+    }
 
-                if (successCallback) {
-                  successCallback()
-                }
-              })
-            }, failureCallback)
-          }
+    const newCacheSize = Math.max(DEFAULT_CACHE_SIZE, 2 * numVisiblePages + 1);
+    this.#buffer.resize(newCacheSize, visible.ids);
+    this.renderingQueue.renderHighestPriority(visible);
+    const isSimpleLayout = this._spreadMode === _ui_utils.SpreadMode.NONE && (this._scrollMode === _ui_utils.ScrollMode.PAGE || this._scrollMode === _ui_utils.ScrollMode.VERTICAL);
+    const currentId = this._currentPageNumber;
+    let stillFullyVisible = false;
 
-          function loadLocale (lang, callback) {
-            if (lang) {
-              lang = lang.toLowerCase()
-            }
+    for (const page of visiblePages) {
+      if (page.percent < 100) {
+        break;
+      }
 
-            callback = callback || function _callback () {}
+      if (page.id === currentId && isSimpleLayout) {
+        stillFullyVisible = true;
+        break;
+      }
+    }
 
-            clear()
-            gLanguage = lang
-            var langLinks = getL10nResourceLinks()
-            var langCount = langLinks.length
+    this._setCurrentPageNumber(stillFullyVisible ? currentId : visiblePages[0].id);
+
+    this._updateLocation(visible.first);
+
+    this.eventBus.dispatch("updateviewarea", {
+      source: this,
+      location: this._location
+    });
+  }
+
+  containsElement(element) {
+    return this.container.contains(element);
+  }
+
+  focus() {
+    this.container.focus();
+  }
+
+  get _isContainerRtl() {
+    return getComputedStyle(this.container).direction === "rtl";
+  }
+
+  get isInPresentationMode() {
+    return this.presentationModeState === _ui_utils.PresentationModeState.FULLSCREEN;
+  }
+
+  get isChangingPresentationMode() {
+    return this.presentationModeState === _ui_utils.PresentationModeState.CHANGING;
+  }
+
+  get isHorizontalScrollbarEnabled() {
+    return this.isInPresentationMode ? false : this.container.scrollWidth > this.container.clientWidth;
+  }
+
+  get isVerticalScrollbarEnabled() {
+    return this.isInPresentationMode ? false : this.container.scrollHeight > this.container.clientHeight;
+  }
+
+  _getVisiblePages() {
+    const views = this._scrollMode === _ui_utils.ScrollMode.PAGE ? this.#scrollModePageState.pages : this._pages,
+          horizontal = this._scrollMode === _ui_utils.ScrollMode.HORIZONTAL,
+          rtl = horizontal && this._isContainerRtl;
+    return (0, _ui_utils.getVisibleElements)({
+      scrollEl: this.container,
+      views,
+      sortByVisibility: true,
+      horizontal,
+      rtl
+    });
+  }
+
+  isPageVisible(pageNumber) {
+    if (!this.pdfDocument) {
+      return false;
+    }
 
-            if (langCount === 0) {
-              var dict = getL10nDictionary()
+    if (!(Number.isInteger(pageNumber) && pageNumber > 0 && pageNumber <= this.pagesCount)) {
+      console.error(`isPageVisible: "${pageNumber}" is not a valid page.`);
+      return false;
+    }
 
-              if (dict && dict.locales && dict.default_locale) {
-                console.log('using the embedded JSON directory, early way out')
-                gL10nData = dict.locales[lang]
+    return this._getVisiblePages().ids.has(pageNumber);
+  }
 
-                if (!gL10nData) {
-                  var defaultLocale = dict.default_locale.toLowerCase()
+  isPageCached(pageNumber) {
+    if (!this.pdfDocument) {
+      return false;
+    }
 
-                  for (var anyCaseLang in dict.locales) {
-                    anyCaseLang = anyCaseLang.toLowerCase()
+    if (!(Number.isInteger(pageNumber) && pageNumber > 0 && pageNumber <= this.pagesCount)) {
+      console.error(`isPageCached: "${pageNumber}" is not a valid page.`);
+      return false;
+    }
 
-                    if (anyCaseLang === lang) {
-                      gL10nData = dict.locales[lang]
-                      break
-                    } else if (anyCaseLang === defaultLocale) {
-                      gL10nData = dict.locales[defaultLocale]
-                    }
-                  }
-                }
+    const pageView = this._pages[pageNumber - 1];
+    return this.#buffer.has(pageView);
+  }
 
-                callback()
-              } else {
-                console.log('no resource to load, early way out')
-              }
-
-              gReadyState = 'complete'
-              return
-            }
-
-            var onResourceLoaded = null
-            var gResourceCount = 0
-
-            onResourceLoaded = function () {
-              gResourceCount++
-
-              if (gResourceCount >= langCount) {
-                callback()
-                gReadyState = 'complete'
-              }
-            }
-
-            function L10nResourceLink (link) {
-              var href = link.href
-
-              this.load = function (lang, callback) {
-                parseResource(href, lang, callback, function () {
-                  console.warn(href + ' not found.')
-                  console.warn('"' + lang + '" resource not found')
-                  gLanguage = ''
-                  callback()
-                })
-              }
-            }
-
-            for (var i = 0; i < langCount; i++) {
-              var resource = new L10nResourceLink(langLinks[i])
-              resource.load(lang, onResourceLoaded)
-            }
-          }
-
-          function clear () {
-            gL10nData = {}
-            gTextData = ''
-            gLanguage = ''
-          }
-
-          function getPluralRules (lang) {
-            var locales2rules = {
-              'af': 3,
-              'ak': 4,
-              'am': 4,
-              'ar': 1,
-              'asa': 3,
-              'az': 0,
-              'be': 11,
-              'bem': 3,
-              'bez': 3,
-              'bg': 3,
-              'bh': 4,
-              'bm': 0,
-              'bn': 3,
-              'bo': 0,
-              'br': 20,
-              'brx': 3,
-              'bs': 11,
-              'ca': 3,
-              'cgg': 3,
-              'chr': 3,
-              'cs': 12,
-              'cy': 17,
-              'da': 3,
-              'de': 3,
-              'dv': 3,
-              'dz': 0,
-              'ee': 3,
-              'el': 3,
-              'en': 3,
-              'eo': 3,
-              'es': 3,
-              'et': 3,
-              'eu': 3,
-              'fa': 0,
-              'ff': 5,
-              'fi': 3,
-              'fil': 4,
-              'fo': 3,
-              'fr': 5,
-              'fur': 3,
-              'fy': 3,
-              'ga': 8,
-              'gd': 24,
-              'gl': 3,
-              'gsw': 3,
-              'gu': 3,
-              'guw': 4,
-              'gv': 23,
-              'ha': 3,
-              'haw': 3,
-              'he': 2,
-              'hi': 4,
-              'hr': 11,
-              'hu': 0,
-              'id': 0,
-              'ig': 0,
-              'ii': 0,
-              'is': 3,
-              'it': 3,
-              'iu': 7,
-              'ja': 0,
-              'jmc': 3,
-              'jv': 0,
-              'ka': 0,
-              'kab': 5,
-              'kaj': 3,
-              'kcg': 3,
-              'kde': 0,
-              'kea': 0,
-              'kk': 3,
-              'kl': 3,
-              'km': 0,
-              'kn': 0,
-              'ko': 0,
-              'ksb': 3,
-              'ksh': 21,
-              'ku': 3,
-              'kw': 7,
-              'lag': 18,
-              'lb': 3,
-              'lg': 3,
-              'ln': 4,
-              'lo': 0,
-              'lt': 10,
-              'lv': 6,
-              'mas': 3,
-              'mg': 4,
-              'mk': 16,
-              'ml': 3,
-              'mn': 3,
-              'mo': 9,
-              'mr': 3,
-              'ms': 0,
-              'mt': 15,
-              'my': 0,
-              'nah': 3,
-              'naq': 7,
-              'nb': 3,
-              'nd': 3,
-              'ne': 3,
-              'nl': 3,
-              'nn': 3,
-              'no': 3,
-              'nr': 3,
-              'nso': 4,
-              'ny': 3,
-              'nyn': 3,
-              'om': 3,
-              'or': 3,
-              'pa': 3,
-              'pap': 3,
-              'pl': 13,
-              'ps': 3,
-              'pt': 3,
-              'rm': 3,
-              'ro': 9,
-              'rof': 3,
-              'ru': 11,
-              'rwk': 3,
-              'sah': 0,
-              'saq': 3,
-              'se': 7,
-              'seh': 3,
-              'ses': 0,
-              'sg': 0,
-              'sh': 11,
-              'shi': 19,
-              'sk': 12,
-              'sl': 14,
-              'sma': 7,
-              'smi': 7,
-              'smj': 7,
-              'smn': 7,
-              'sms': 7,
-              'sn': 3,
-              'so': 3,
-              'sq': 3,
-              'sr': 11,
-              'ss': 3,
-              'ssy': 3,
-              'st': 3,
-              'sv': 3,
-              'sw': 3,
-              'syr': 3,
-              'ta': 3,
-              'te': 3,
-              'teo': 3,
-              'th': 0,
-              'ti': 4,
-              'tig': 3,
-              'tk': 3,
-              'tl': 4,
-              'tn': 3,
-              'to': 0,
-              'tr': 0,
-              'ts': 3,
-              'tzm': 22,
-              'uk': 11,
-              'ur': 3,
-              've': 3,
-              'vi': 0,
-              'vun': 3,
-              'wa': 4,
-              'wae': 3,
-              'wo': 0,
-              'xh': 3,
-              'xog': 3,
-              'yo': 0,
-              'zh': 0,
-              'zu': 3
-            }
-
-            function isIn (n, list) {
-              return list.indexOf(n) !== -1
-            }
-
-            function isBetween (n, start, end) {
-              return start <= n && n <= end
-            }
-
-            var pluralRules = {
-              '0': function (n) {
-                return 'other'
-              },
-              '1': function (n) {
-                if (isBetween(n % 100, 3, 10)) return 'few'
-                if (n === 0) return 'zero'
-                if (isBetween(n % 100, 11, 99)) return 'many'
-                if (n == 2) return 'two'
-                if (n == 1) return 'one'
-                return 'other'
-              },
-              '2': function (n) {
-                if (n !== 0 && n % 10 === 0) return 'many'
-                if (n == 2) return 'two'
-                if (n == 1) return 'one'
-                return 'other'
-              },
-              '3': function (n) {
-                if (n == 1) return 'one'
-                return 'other'
-              },
-              '4': function (n) {
-                if (isBetween(n, 0, 1)) return 'one'
-                return 'other'
-              },
-              '5': function (n) {
-                if (isBetween(n, 0, 2) && n != 2) return 'one'
-                return 'other'
-              },
-              '6': function (n) {
-                if (n === 0) return 'zero'
-                if (n % 10 == 1 && n % 100 != 11) return 'one'
-                return 'other'
-              },
-              '7': function (n) {
-                if (n == 2) return 'two'
-                if (n == 1) return 'one'
-                return 'other'
-              },
-              '8': function (n) {
-                if (isBetween(n, 3, 6)) return 'few'
-                if (isBetween(n, 7, 10)) return 'many'
-                if (n == 2) return 'two'
-                if (n == 1) return 'one'
-                return 'other'
-              },
-              '9': function (n) {
-                if (n === 0 || n != 1 && isBetween(n % 100, 1, 19)) return 'few'
-                if (n == 1) return 'one'
-                return 'other'
-              },
-              '10': function (n) {
-                if (isBetween(n % 10, 2, 9) && !isBetween(n % 100, 11, 19)) return 'few'
-                if (n % 10 == 1 && !isBetween(n % 100, 11, 19)) return 'one'
-                return 'other'
-              },
-              '11': function (n) {
-                if (isBetween(n % 10, 2, 4) && !isBetween(n % 100, 12, 14)) return 'few'
-                if (n % 10 === 0 || isBetween(n % 10, 5, 9) || isBetween(n % 100, 11, 14)) return 'many'
-                if (n % 10 == 1 && n % 100 != 11) return 'one'
-                return 'other'
-              },
-              '12': function (n) {
-                if (isBetween(n, 2, 4)) return 'few'
-                if (n == 1) return 'one'
-                return 'other'
-              },
-              '13': function (n) {
-                if (isBetween(n % 10, 2, 4) && !isBetween(n % 100, 12, 14)) return 'few'
-                if (n != 1 && isBetween(n % 10, 0, 1) || isBetween(n % 10, 5, 9) || isBetween(n % 100, 12, 14)) return 'many'
-                if (n == 1) return 'one'
-                return 'other'
-              },
-              '14': function (n) {
-                if (isBetween(n % 100, 3, 4)) return 'few'
-                if (n % 100 == 2) return 'two'
-                if (n % 100 == 1) return 'one'
-                return 'other'
-              },
-              '15': function (n) {
-                if (n === 0 || isBetween(n % 100, 2, 10)) return 'few'
-                if (isBetween(n % 100, 11, 19)) return 'many'
-                if (n == 1) return 'one'
-                return 'other'
-              },
-              '16': function (n) {
-                if (n % 10 == 1 && n != 11) return 'one'
-                return 'other'
-              },
-              '17': function (n) {
-                if (n == 3) return 'few'
-                if (n === 0) return 'zero'
-                if (n == 6) return 'many'
-                if (n == 2) return 'two'
-                if (n == 1) return 'one'
-                return 'other'
-              },
-              '18': function (n) {
-                if (n === 0) return 'zero'
-                if (isBetween(n, 0, 2) && n !== 0 && n != 2) return 'one'
-                return 'other'
-              },
-              '19': function (n) {
-                if (isBetween(n, 2, 10)) return 'few'
-                if (isBetween(n, 0, 1)) return 'one'
-                return 'other'
-              },
-              '20': function (n) {
-                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'
-                if (n % 1000000 === 0 && n !== 0) return 'many'
-                if (n % 10 == 2 && !isIn(n % 100, [12, 72, 92])) return 'two'
-                if (n % 10 == 1 && !isIn(n % 100, [11, 71, 91])) return 'one'
-                return 'other'
-              },
-              '21': function (n) {
-                if (n === 0) return 'zero'
-                if (n == 1) return 'one'
-                return 'other'
-              },
-              '22': function (n) {
-                if (isBetween(n, 0, 1) || isBetween(n, 11, 99)) return 'one'
-                return 'other'
-              },
-              '23': function (n) {
-                if (isBetween(n % 10, 1, 2) || n % 20 === 0) return 'one'
-                return 'other'
-              },
-              '24': function (n) {
-                if (isBetween(n, 3, 10) || isBetween(n, 13, 19)) return 'few'
-                if (isIn(n, [2, 12])) return 'two'
-                if (isIn(n, [1, 11])) return 'one'
-                return 'other'
-              }
-            }
-            var index = locales2rules[lang.replace(/-.*$/, '')]
-
-            if (!(index in pluralRules)) {
-              console.warn('plural form unknown for [' + lang + ']')
-              return function () {
-                return 'other'
-              }
-            }
-
-            return pluralRules[index]
-          }
+  cleanup() {
+    for (const pageView of this._pages) {
+      if (pageView.renderingState !== _ui_utils.RenderingStates.FINISHED) {
+        pageView.reset();
+      }
+    }
+  }
 
-          gMacros.plural = function (str, param, key, prop) {
-            var n = parseFloat(param)
-            if (isNaN(n)) return str
-            if (prop != gTextProp) return str
+  _cancelRendering() {
+    for (const pageView of this._pages) {
+      pageView.cancelRendering();
+    }
+  }
 
-            if (!gMacros._pluralRules) {
-              gMacros._pluralRules = getPluralRules(gLanguage)
-            }
+  async #ensurePdfPageLoaded(pageView) {
+    if (pageView.pdfPage) {
+      return pageView.pdfPage;
+    }
 
-            var index = '[' + gMacros._pluralRules(n) + ']'
-
-            if (n === 0 && key + '[zero]' in gL10nData) {
-              str = gL10nData[key + '[zero]'][prop]
-            } else if (n == 1 && key + '[one]' in gL10nData) {
-              str = gL10nData[key + '[one]'][prop]
-            } else if (n == 2 && key + '[two]' in gL10nData) {
-              str = gL10nData[key + '[two]'][prop]
-            } else if (key + index in gL10nData) {
-              str = gL10nData[key + index][prop]
-            } else if (key + '[other]' in gL10nData) {
-              str = gL10nData[key + '[other]'][prop]
-            }
+    try {
+      const pdfPage = await this.pdfDocument.getPage(pageView.id);
 
-            return str
-          }
+      if (!pageView.pdfPage) {
+        pageView.setPdfPage(pdfPage);
+      }
 
-          function getL10nData (key, args, fallback) {
-            var data = gL10nData[key]
+      if (!this.linkService._cachedPageNumber?.(pdfPage.ref)) {
+        this.linkService.cachePageRef(pageView.id, pdfPage.ref);
+      }
 
-            if (!data) {
-              console.warn('#' + key + ' is undefined.')
+      return pdfPage;
+    } catch (reason) {
+      console.error("Unable to get page for page view", reason);
+      return null;
+    }
+  }
 
-              if (!fallback) {
-                return null
-              }
+  #getScrollAhead(visible) {
+    if (visible.first?.id === 1) {
+      return true;
+    } else if (visible.last?.id === this.pagesCount) {
+      return false;
+    }
 
-              data = fallback
-            }
+    switch (this._scrollMode) {
+      case _ui_utils.ScrollMode.PAGE:
+        return this.#scrollModePageState.scrollDown;
 
-            var rv = {}
+      case _ui_utils.ScrollMode.HORIZONTAL:
+        return this.scroll.right;
+    }
 
-            for (var prop in data) {
-              var str = data[prop]
-              str = substIndexes(str, args, key, prop)
-              str = substArguments(str, args, key)
-              rv[prop] = str
-            }
+    return this.scroll.down;
+  }
 
-            return rv
-          }
+  #toggleLoadingIconSpinner(visibleIds) {
+    for (const id of visibleIds) {
+      const pageView = this._pages[id - 1];
+      pageView?.toggleLoadingIconSpinner(true);
+    }
 
-          function substIndexes (str, args, key, prop) {
-            var reIndex = /\{\[\s*([a-zA-Z]+)\(([a-zA-Z]+)\)\s*\]\}/
-            var reMatch = reIndex.exec(str)
-            if (!reMatch || !reMatch.length) return str
-            var macroName = reMatch[1]
-            var paramName = reMatch[2]
-            var param
-
-            if (args && paramName in args) {
-              param = args[paramName]
-            } else if (paramName in gL10nData) {
-              param = gL10nData[paramName]
-            }
+    for (const pageView of this.#buffer) {
+      if (visibleIds.has(pageView.id)) {
+        continue;
+      }
 
-            if (macroName in gMacros) {
-              var macro = gMacros[macroName]
-              str = macro(str, param, key, prop)
-            }
+      pageView.toggleLoadingIconSpinner(false);
+    }
+  }
 
-            return str
-          }
+  forceRendering(currentlyVisiblePages) {
+    const visiblePages = currentlyVisiblePages || this._getVisiblePages();
 
-          function substArguments (str, args, key) {
-            var reArgs = /\{\{\s*(.+?)\s*\}\}/g
-            return str.replace(reArgs, function (matched_text, arg) {
-              if (args && arg in args) {
-                return args[arg]
-              }
+    const scrollAhead = this.#getScrollAhead(visiblePages);
+    const preRenderExtra = this._spreadMode !== _ui_utils.SpreadMode.NONE && this._scrollMode !== _ui_utils.ScrollMode.HORIZONTAL;
+    const pageView = this.renderingQueue.getHighestPriority(visiblePages, this._pages, scrollAhead, preRenderExtra);
+    this.#toggleLoadingIconSpinner(visiblePages.ids);
 
-              if (arg in gL10nData) {
-                return gL10nData[arg]
-              }
+    if (pageView) {
+      this.#ensurePdfPageLoaded(pageView).then(() => {
+        this.renderingQueue.renderView(pageView);
+      });
+      return true;
+    }
 
-              console.log('argument {{' + arg + '}} for #' + key + ' is undefined.')
-              return matched_text
-            })
-          }
+    return false;
+  }
+
+  createTextLayerBuilder(textLayerDiv, pageIndex, viewport, enhanceTextSelection = false, eventBus, highlighter) {
+    return new _text_layer_builder.TextLayerBuilder({
+      textLayerDiv,
+      eventBus,
+      pageIndex,
+      viewport,
+      enhanceTextSelection: this.isInPresentationMode ? false : enhanceTextSelection,
+      highlighter
+    });
+  }
+
+  createTextHighlighter(pageIndex, eventBus) {
+    return new _text_highlighter.TextHighlighter({
+      eventBus,
+      pageIndex,
+      findController: this.isInPresentationMode ? null : this.findController
+    });
+  }
+
+  createAnnotationLayerBuilder(pageDiv, pdfPage, annotationStorage = null, imageResourcesPath = "", renderForms = true, l10n = _l10n_utils.NullL10n, enableScripting = null, hasJSActionsPromise = null, mouseState = null, fieldObjectsPromise = null, annotationCanvasMap = null) {
+    return new _annotation_layer_builder.AnnotationLayerBuilder({
+      pageDiv,
+      pdfPage,
+      annotationStorage: annotationStorage || this.pdfDocument?.annotationStorage,
+      imageResourcesPath,
+      renderForms,
+      linkService: this.linkService,
+      downloadManager: this.downloadManager,
+      l10n,
+      enableScripting: enableScripting ?? this.enableScripting,
+      hasJSActionsPromise: hasJSActionsPromise || this.pdfDocument?.hasJSActions(),
+      fieldObjectsPromise: fieldObjectsPromise || this.pdfDocument?.getFieldObjects(),
+      mouseState: mouseState || this._scriptingManager?.mouseState,
+      annotationCanvasMap
+    });
+  }
+
+  createXfaLayerBuilder(pageDiv, pdfPage, annotationStorage = null) {
+    return new _xfa_layer_builder.XfaLayerBuilder({
+      pageDiv,
+      pdfPage,
+      annotationStorage: annotationStorage || this.pdfDocument?.annotationStorage,
+      linkService: this.linkService
+    });
+  }
+
+  createStructTreeLayerBuilder(pdfPage) {
+    return new _struct_tree_layer_builder.StructTreeLayerBuilder({
+      pdfPage
+    });
+  }
+
+  get hasEqualPageSizes() {
+    const firstPageView = this._pages[0];
+
+    for (let i = 1, ii = this._pages.length; i < ii; ++i) {
+      const pageView = this._pages[i];
+
+      if (pageView.width !== firstPageView.width || pageView.height !== firstPageView.height) {
+        return false;
+      }
+    }
 
-          function translateElement (element) {
-            var l10n = getL10nAttributes(element)
-            if (!l10n.id) return
-            var data = getL10nData(l10n.id, l10n.args)
+    return true;
+  }
+
+  getPagesOverview() {
+    return this._pages.map(pageView => {
+      const viewport = pageView.pdfPage.getViewport({
+        scale: 1
+      });
+
+      if (!this.enablePrintAutoRotate || (0, _ui_utils.isPortraitOrientation)(viewport)) {
+        return {
+          width: viewport.width,
+          height: viewport.height,
+          rotation: viewport.rotation
+        };
+      }
 
-            if (!data) {
-              console.warn('#' + l10n.id + ' is undefined.')
-              return
-            }
+      return {
+        width: viewport.height,
+        height: viewport.width,
+        rotation: (viewport.rotation - 90) % 360
+      };
+    });
+  }
+
+  get optionalContentConfigPromise() {
+    if (!this.pdfDocument) {
+      return Promise.resolve(null);
+    }
 
-            if (data[gTextProp]) {
-              if (getChildElementCount(element) === 0) {
-                element[gTextProp] = data[gTextProp]
-              } else {
-                var children = element.childNodes
-                var found = false
-
-                for (var i = 0, l = children.length; i < l; i++) {
-                  if (children[i].nodeType === 3 && /\S/.test(children[i].nodeValue)) {
-                    if (found) {
-                      children[i].nodeValue = ''
-                    } else {
-                      children[i].nodeValue = data[gTextProp]
-                      found = true
-                    }
-                  }
-                }
+    if (!this._optionalContentConfigPromise) {
+      return this.pdfDocument.getOptionalContentConfig();
+    }
 
-                if (!found) {
-                  var textNode = document.createTextNode(data[gTextProp])
-                  element.insertBefore(textNode, element.firstChild)
-                }
-              }
+    return this._optionalContentConfigPromise;
+  }
 
-              delete data[gTextProp]
-            }
+  set optionalContentConfigPromise(promise) {
+    if (!(promise instanceof Promise)) {
+      throw new Error(`Invalid optionalContentConfigPromise: ${promise}`);
+    }
 
-            for (var k in data) {
-              element[k] = data[k]
-            }
-          }
+    if (!this.pdfDocument) {
+      return;
+    }
 
-          function getChildElementCount (element) {
-            if (element.children) {
-              return element.children.length
-            }
+    if (!this._optionalContentConfigPromise) {
+      return;
+    }
 
-            if (typeof element.childElementCount !== 'undefined') {
-              return element.childElementCount
-            }
+    this._optionalContentConfigPromise = promise;
+    const updateArgs = {
+      optionalContentConfigPromise: promise
+    };
 
-            var count = 0
+    for (const pageView of this._pages) {
+      pageView.update(updateArgs);
+    }
 
-            for (var i = 0; i < element.childNodes.length; i++) {
-              count += element.nodeType === 1 ? 1 : 0
-            }
+    this.update();
+    this.eventBus.dispatch("optionalcontentconfigchanged", {
+      source: this,
+      promise
+    });
+  }
 
-            return count
-          }
+  get scrollMode() {
+    return this._scrollMode;
+  }
 
-          function translateFragment (element) {
-            element = element || document.documentElement
-            var children = getTranslatableChildren(element)
-            var elementCount = children.length
+  set scrollMode(mode) {
+    if (this._scrollMode === mode) {
+      return;
+    }
 
-            for (var i = 0; i < elementCount; i++) {
-              translateElement(children[i])
-            }
+    if (!(0, _ui_utils.isValidScrollMode)(mode)) {
+      throw new Error(`Invalid scroll mode: ${mode}`);
+    }
 
-            translateElement(element)
-          }
+    if (this.pagesCount > PagesCountLimit.FORCE_SCROLL_MODE_PAGE) {
+      return;
+    }
 
-          return {
-            get: function (key, args, fallbackString) {
-              var index = key.lastIndexOf('.')
-              var prop = gTextProp
+    this._previousScrollMode = this._scrollMode;
+    this._scrollMode = mode;
+    this.eventBus.dispatch("scrollmodechanged", {
+      source: this,
+      mode
+    });
 
-              if (index > 0) {
-                prop = key.substring(index + 1)
-                key = key.substring(0, index)
-              }
+    this._updateScrollMode(this._currentPageNumber);
+  }
 
-              var fallback
+  _updateScrollMode(pageNumber = null) {
+    const scrollMode = this._scrollMode,
+          viewer = this.viewer;
+    viewer.classList.toggle("scrollHorizontal", scrollMode === _ui_utils.ScrollMode.HORIZONTAL);
+    viewer.classList.toggle("scrollWrapped", scrollMode === _ui_utils.ScrollMode.WRAPPED);
 
-              if (fallbackString) {
-                fallback = {}
-                fallback[prop] = fallbackString
-              }
+    if (!this.pdfDocument || !pageNumber) {
+      return;
+    }
 
-              var data = getL10nData(key, args, fallback)
+    if (scrollMode === _ui_utils.ScrollMode.PAGE) {
+      this.#ensurePageViewVisible();
+    } else if (this._previousScrollMode === _ui_utils.ScrollMode.PAGE) {
+      this._updateSpreadMode();
+    }
 
-              if (data && prop in data) {
-                return data[prop]
-              }
+    if (this._currentScaleValue && isNaN(this._currentScaleValue)) {
+      this._setScale(this._currentScaleValue, true);
+    }
 
-              return '{{' + key + '}}'
-            },
-            getData: function () {
-              return gL10nData
-            },
-            getText: function () {
-              return gTextData
-            },
-            getLanguage: function () {
-              return gLanguage
-            },
-            setLanguage: function (lang, callback) {
-              loadLocale(lang, function () {
-                if (callback) callback()
-              })
-            },
-            getDirection: function () {
-              var rtlList = ['ar', 'he', 'fa', 'ps', 'ur']
-              var shortCode = gLanguage.split('-', 1)[0]
-              return rtlList.indexOf(shortCode) >= 0 ? 'rtl' : 'ltr'
-            },
-            translate: translateFragment,
-            getReadyState: function () {
-              return gReadyState
-            },
-            ready: function (callback) {
-              if (!callback) {
-                return
-              } else if (gReadyState == 'complete' || gReadyState == 'interactive') {
-                window.setTimeout(function () {
-                  callback()
-                })
-              } else if (document.addEventListener) {
-                document.addEventListener('localized', function once () {
-                  document.removeEventListener('localized', once)
-                  callback()
-                })
-              }
-            }
-          }
-        }(window, document)
+    this._setCurrentPageNumber(pageNumber, true);
 
-        /***/
-      }),
-      /* 11 */
-      /***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+    this.update();
+  }
 
-        Object.defineProperty(exports, '__esModule', ({
-          value: true
-        }))
-        exports.PDFFindController = exports.FindState = void 0
+  get spreadMode() {
+    return this._spreadMode;
+  }
 
-        var _pdfjsLib = __w_pdfjs_require__(2)
+  set spreadMode(mode) {
+    if (this._spreadMode === mode) {
+      return;
+    }
 
-        var _pdf_find_utils = __w_pdfjs_require__(12)
+    if (!(0, _ui_utils.isValidSpreadMode)(mode)) {
+      throw new Error(`Invalid spread mode: ${mode}`);
+    }
 
-        var _ui_utils = __w_pdfjs_require__(5)
+    this._spreadMode = mode;
+    this.eventBus.dispatch("spreadmodechanged", {
+      source: this,
+      mode
+    });
 
-        const FindState = {
-          FOUND: 0,
-          NOT_FOUND: 1,
-          WRAPPED: 2,
-          PENDING: 3
-        }
-        exports.FindState = FindState
-        const FIND_TIMEOUT = 250
-        const MATCH_SCROLL_OFFSET_TOP = -50
-        const MATCH_SCROLL_OFFSET_LEFT = -400
-        const CHARACTERS_TO_NORMALIZE = {
-          '\u2018': '\'',
-          '\u2019': '\'',
-          '\u201A': '\'',
-          '\u201B': '\'',
-          '\u201C': '"',
-          '\u201D': '"',
-          '\u201E': '"',
-          '\u201F': '"',
-          '\u00BC': '1/4',
-          '\u00BD': '1/2',
-          '\u00BE': '3/4'
-        }
-        let normalizationRegex = null
+    this._updateSpreadMode(this._currentPageNumber);
+  }
 
-        function normalize (text) {
-          if (!normalizationRegex) {
-            const replace = Object.keys(CHARACTERS_TO_NORMALIZE).join('')
-            normalizationRegex = new RegExp(`[${replace}]`, 'g')
-          }
+  _updateSpreadMode(pageNumber = null) {
+    if (!this.pdfDocument) {
+      return;
+    }
 
-          let diffs = null
-          const normalizedText = text.replace(normalizationRegex, function (ch, index) {
-            const normalizedCh = CHARACTERS_TO_NORMALIZE[ch],
-              diff = normalizedCh.length - ch.length
+    const viewer = this.viewer,
+          pages = this._pages;
 
-            if (diff !== 0) {
-              (diffs || (diffs = [])).push([index, diff])
-            }
+    if (this._scrollMode === _ui_utils.ScrollMode.PAGE) {
+      this.#ensurePageViewVisible();
+    } else {
+      viewer.textContent = "";
 
-            return normalizedCh
-          })
-          return [normalizedText, diffs]
+      if (this._spreadMode === _ui_utils.SpreadMode.NONE) {
+        for (const pageView of this._pages) {
+          viewer.appendChild(pageView.div);
         }
+      } else {
+        const parity = this._spreadMode - 1;
+        let spread = null;
 
-        function getOriginalIndex (matchIndex, diffs = null) {
-          if (!diffs) {
-            return matchIndex
+        for (let i = 0, ii = pages.length; i < ii; ++i) {
+          if (spread === null) {
+            spread = document.createElement("div");
+            spread.className = "spread";
+            viewer.appendChild(spread);
+          } else if (i % 2 === parity) {
+            spread = spread.cloneNode(false);
+            viewer.appendChild(spread);
           }
 
-          let totalDiff = 0
-
-          for (const [index, diff] of diffs) {
-            const currentIndex = index + totalDiff
-
-            if (currentIndex >= matchIndex) {
-              break
-            }
-
-            if (currentIndex + diff > matchIndex) {
-              totalDiff += matchIndex - currentIndex
-              break
-            }
-
-            totalDiff += diff
-          }
-
-          return matchIndex - totalDiff
+          spread.appendChild(pages[i].div);
         }
+      }
+    }
 
-        class PDFFindController {
-          constructor ({
-            linkService,
-            eventBus
-          }) {
-            this._linkService = linkService
-            this._eventBus = eventBus
-
-            this._reset()
-
-            eventBus._on('findbarclose', this._onFindBarClose.bind(this))
-          }
-
-          get highlightMatches () {
-            return this._highlightMatches
-          }
-
-          get pageMatches () {
-            return this._pageMatches
-          }
-
-          get pageMatchesLength () {
-            return this._pageMatchesLength
-          }
-
-          get selected () {
-            return this._selected
-          }
-
-          get state () {
-            return this._state
-          }
-
-          setDocument (pdfDocument) {
-            if (this._pdfDocument) {
-              this._reset()
-            }
-
-            if (!pdfDocument) {
-              return
-            }
+    if (!pageNumber) {
+      return;
+    }
 
-            this._pdfDocument = pdfDocument
+    if (this._currentScaleValue && isNaN(this._currentScaleValue)) {
+      this._setScale(this._currentScaleValue, true);
+    }
 
-            this._firstPageCapability.resolve()
-          }
+    this._setCurrentPageNumber(pageNumber, true);
 
-          executeCommand (cmd, state) {
-            if (!state) {
-              return
-            }
+    this.update();
+  }
 
-            const pdfDocument = this._pdfDocument
+  _getPageAdvance(currentPageNumber, previous = false) {
+    switch (this._scrollMode) {
+      case _ui_utils.ScrollMode.WRAPPED:
+        {
+          const {
+            views
+          } = this._getVisiblePages(),
+                pageLayout = new Map();
 
-            if (this._state === null || this._shouldDirtyMatch(cmd, state)) {
-              this._dirtyMatch = true
+          for (const {
+            id,
+            y,
+            percent,
+            widthPercent
+          } of views) {
+            if (percent === 0 || widthPercent < 100) {
+              continue;
             }
 
-            this._state = state
+            let yArray = pageLayout.get(y);
 
-            if (cmd !== 'findhighlightallchange') {
-              this._updateUIState(FindState.PENDING)
+            if (!yArray) {
+              pageLayout.set(y, yArray ||= []);
             }
 
-            this._firstPageCapability.promise.then(() => {
-              if (!this._pdfDocument || pdfDocument && this._pdfDocument !== pdfDocument) {
-                return
-              }
-
-              this._extractText()
-
-              const findbarClosed = !this._highlightMatches
-              const pendingTimeout = !!this._findTimeout
-
-              if (this._findTimeout) {
-                clearTimeout(this._findTimeout)
-                this._findTimeout = null
-              }
-
-              if (cmd === 'find') {
-                this._findTimeout = setTimeout(() => {
-                  this._nextMatch()
-
-                  this._findTimeout = null
-                }, FIND_TIMEOUT)
-              } else if (this._dirtyMatch) {
-                this._nextMatch()
-              } else if (cmd === 'findagain') {
-                this._nextMatch()
-
-                if (findbarClosed && this._state.highlightAll) {
-                  this._updateAllPages()
-                }
-              } else if (cmd === 'findhighlightallchange') {
-                if (pendingTimeout) {
-                  this._nextMatch()
-                } else {
-                  this._highlightMatches = true
-                }
-
-                this._updateAllPages()
-              } else {
-                this._nextMatch()
-              }
-            })
+            yArray.push(id);
           }
 
-          scrollMatchIntoView ({
-            element = null,
-            pageIndex = -1,
-            matchIndex = -1
-          }) {
-            if (!this._scrollMatches || !element) {
-              return
-            } else if (matchIndex === -1 || matchIndex !== this._selected.matchIdx) {
-              return
-            } else if (pageIndex === -1 || pageIndex !== this._selected.pageIdx) {
-              return
-            }
-
-            this._scrollMatches = false
-            const spot = {
-              top: MATCH_SCROLL_OFFSET_TOP,
-              left: MATCH_SCROLL_OFFSET_LEFT
-            };
-            (0, _ui_utils.scrollIntoView)(element, spot, true)
-          }
-
-          _reset () {
-            this._highlightMatches = false
-            this._scrollMatches = false
-            this._pdfDocument = null
-            this._pageMatches = []
-            this._pageMatchesLength = []
-            this._state = null
-            this._selected = {
-              pageIdx: -1,
-              matchIdx: -1
-            }
-            this._offset = {
-              pageIdx: null,
-              matchIdx: null,
-              wrapped: false
-            }
-            this._extractTextPromises = []
-            this._pageContents = []
-            this._pageDiffs = []
-            this._matchesCountTotal = 0
-            this._pagesToSearch = null
-            this._pendingFindMatches = Object.create(null)
-            this._resumePageIdx = null
-            this._dirtyMatch = false
-            clearTimeout(this._findTimeout)
-            this._findTimeout = null
-            this._firstPageCapability = (0, _pdfjsLib.createPromiseCapability)()
-          }
-
-          get _query () {
-            if (this._state.query !== this._rawQuery) {
-              this._rawQuery = this._state.query;
-              [this._normalizedQuery] = normalize(this._state.query)
-            }
-
-            return this._normalizedQuery
-          }
+          for (const yArray of pageLayout.values()) {
+            const currentIndex = yArray.indexOf(currentPageNumber);
 
-          _shouldDirtyMatch (cmd, state) {
-            if (state.query !== this._state.query) {
-              return true
+            if (currentIndex === -1) {
+              continue;
             }
 
-            switch (cmd) {
-              case 'findagain':
-                const pageNumber = this._selected.pageIdx + 1
-                const linkService = this._linkService
-
-                if (pageNumber >= 1 && pageNumber <= linkService.pagesCount && pageNumber !== linkService.page && !linkService.isPageVisible(pageNumber)) {
-                  return true
-                }
-
-                return false
+            const numPages = yArray.length;
 
-              case 'findhighlightallchange':
-                return false
+            if (numPages === 1) {
+              break;
             }
 
-            return true
-          }
-
-          _prepareMatches (matchesWithLength, matches, matchesLength) {
-            function isSubTerm (currentIndex) {
-              const currentElem = matchesWithLength[currentIndex]
-              const nextElem = matchesWithLength[currentIndex + 1]
-
-              if (currentIndex < matchesWithLength.length - 1 && currentElem.match === nextElem.match) {
-                currentElem.skipped = true
-                return true
-              }
-
-              for (let i = currentIndex - 1; i >= 0; i--) {
-                const prevElem = matchesWithLength[i]
-
-                if (prevElem.skipped) {
-                  continue
-                }
-
-                if (prevElem.match + prevElem.matchLength < currentElem.match) {
-                  break
-                }
+            if (previous) {
+              for (let i = currentIndex - 1, ii = 0; i >= ii; i--) {
+                const currentId = yArray[i],
+                      expectedId = yArray[i + 1] - 1;
 
-                if (prevElem.match + prevElem.matchLength >= currentElem.match + currentElem.matchLength) {
-                  currentElem.skipped = true
-                  return true
+                if (currentId < expectedId) {
+                  return currentPageNumber - expectedId;
                 }
               }
-
-              return false
-            }
-
-            matchesWithLength.sort(function (a, b) {
-              return a.match === b.match ? a.matchLength - b.matchLength : a.match - b.match
-            })
-
-            for (let i = 0, len = matchesWithLength.length; i < len; i++) {
-              if (isSubTerm(i)) {
-                continue
-              }
-
-              matches.push(matchesWithLength[i].match)
-              matchesLength.push(matchesWithLength[i].matchLength)
-            }
-          }
-
-          _isEntireWord (content, startIdx, length) {
-            if (startIdx > 0) {
-              const first = content.charCodeAt(startIdx)
-              const limit = content.charCodeAt(startIdx - 1)
-
-              if ((0, _pdf_find_utils.getCharacterType)(first) === (0, _pdf_find_utils.getCharacterType)(limit)) {
-                return false
-              }
-            }
-
-            const endIdx = startIdx + length - 1
-
-            if (endIdx < content.length - 1) {
-              const last = content.charCodeAt(endIdx)
-              const limit = content.charCodeAt(endIdx + 1)
-
-              if ((0, _pdf_find_utils.getCharacterType)(last) === (0, _pdf_find_utils.getCharacterType)(limit)) {
-                return false
-              }
-            }
-
-            return true
-          }
-
-          _calculatePhraseMatch (query, pageIndex, pageContent, pageDiffs, entireWord) {
-            const matches = [],
-              matchesLength = []
-            const queryLen = query.length
-            let matchIdx = -queryLen
-
-            while (true) {
-              matchIdx = pageContent.indexOf(query, matchIdx + queryLen)
-
-              if (matchIdx === -1) {
-                break
-              }
-
-              if (entireWord && !this._isEntireWord(pageContent, matchIdx, queryLen)) {
-                continue
-              }
-
-              const originalMatchIdx = getOriginalIndex(matchIdx, pageDiffs),
-                matchEnd = matchIdx + queryLen - 1,
-                originalQueryLen = getOriginalIndex(matchEnd, pageDiffs) - originalMatchIdx + 1
-              matches.push(originalMatchIdx)
-              matchesLength.push(originalQueryLen)
-            }
-
-            this._pageMatches[pageIndex] = matches
-            this._pageMatchesLength[pageIndex] = matchesLength
-          }
-
-          _calculateWordMatch (query, pageIndex, pageContent, pageDiffs, entireWord) {
-            const matchesWithLength = []
-            const queryArray = query.match(/\S+/g)
-
-            for (let i = 0, len = queryArray.length; i < len; i++) {
-              const subquery = queryArray[i]
-              const subqueryLen = subquery.length
-              let matchIdx = -subqueryLen
-
-              while (true) {
-                matchIdx = pageContent.indexOf(subquery, matchIdx + subqueryLen)
-
-                if (matchIdx === -1) {
-                  break
-                }
-
-                if (entireWord && !this._isEntireWord(pageContent, matchIdx, subqueryLen)) {
-                  continue
-                }
-
-                const originalMatchIdx = getOriginalIndex(matchIdx, pageDiffs),
-                  matchEnd = matchIdx + subqueryLen - 1,
-                  originalQueryLen = getOriginalIndex(matchEnd, pageDiffs) - originalMatchIdx + 1
-                matchesWithLength.push({
-                  match: originalMatchIdx,
-                  matchLength: originalQueryLen,
-                  skipped: false
-                })
-              }
-            }
-
-            this._pageMatchesLength[pageIndex] = []
-            this._pageMatches[pageIndex] = []
-
-            this._prepareMatches(matchesWithLength, this._pageMatches[pageIndex], this._pageMatchesLength[pageIndex])
-          }
-
-          _calculateMatch (pageIndex) {
-            let pageContent = this._pageContents[pageIndex]
-            const pageDiffs = this._pageDiffs[pageIndex]
-            let query = this._query
-            const {
-              caseSensitive,
-              entireWord,
-              phraseSearch
-            } = this._state
-
-            if (query.length === 0) {
-              return
-            }
-
-            if (!caseSensitive) {
-              pageContent = pageContent.toLowerCase()
-              query = query.toLowerCase()
-            }
-
-            if (phraseSearch) {
-              this._calculatePhraseMatch(query, pageIndex, pageContent, pageDiffs, entireWord)
             } else {
-              this._calculateWordMatch(query, pageIndex, pageContent, pageDiffs, entireWord)
-            }
+              for (let i = currentIndex + 1, ii = numPages; i < ii; i++) {
+                const currentId = yArray[i],
+                      expectedId = yArray[i - 1] + 1;
 
-            if (this._state.highlightAll) {
-              this._updatePage(pageIndex)
-            }
-
-            if (this._resumePageIdx === pageIndex) {
-              this._resumePageIdx = null
-
-              this._nextPageMatch()
-            }
-
-            const pageMatchesCount = this._pageMatches[pageIndex].length
-
-            if (pageMatchesCount > 0) {
-              this._matchesCountTotal += pageMatchesCount
-
-              this._updateUIResultsCount()
-            }
-          }
-
-          _extractText () {
-            if (this._extractTextPromises.length > 0) {
-              return
-            }
-
-            let promise = Promise.resolve()
-
-            for (let i = 0, ii = this._linkService.pagesCount; i < ii; i++) {
-              const extractTextCapability = (0, _pdfjsLib.createPromiseCapability)()
-              this._extractTextPromises[i] = extractTextCapability.promise
-              promise = promise.then(() => {
-                return this._pdfDocument.getPage(i + 1).then(pdfPage => {
-                  return pdfPage.getTextContent({
-                    normalizeWhitespace: true
-                  })
-                }).then(textContent => {
-                  const textItems = textContent.items
-                  const strBuf = []
-
-                  for (let j = 0, jj = textItems.length; j < jj; j++) {
-                    strBuf.push(textItems[j].str)
-                  }
-
-                  [this._pageContents[i], this._pageDiffs[i]] = normalize(strBuf.join(''))
-                  extractTextCapability.resolve(i)
-                }, reason => {
-                  console.error(`Unable to get text content for page ${i + 1}`, reason)
-                  this._pageContents[i] = ''
-                  this._pageDiffs[i] = null
-                  extractTextCapability.resolve(i)
-                })
-              })
-            }
-          }
-
-          _updatePage (index) {
-            if (this._scrollMatches && this._selected.pageIdx === index) {
-              this._linkService.page = index + 1
-            }
-
-            this._eventBus.dispatch('updatetextlayermatches', {
-              source: this,
-              pageIndex: index
-            })
-          }
-
-          _updateAllPages () {
-            this._eventBus.dispatch('updatetextlayermatches', {
-              source: this,
-              pageIndex: -1
-            })
-          }
-
-          _nextMatch () {
-            const previous = this._state.findPrevious
-            const currentPageIndex = this._linkService.page - 1
-            const numPages = this._linkService.pagesCount
-            this._highlightMatches = true
-
-            if (this._dirtyMatch) {
-              this._dirtyMatch = false
-              this._selected.pageIdx = this._selected.matchIdx = -1
-              this._offset.pageIdx = currentPageIndex
-              this._offset.matchIdx = null
-              this._offset.wrapped = false
-              this._resumePageIdx = null
-              this._pageMatches.length = 0
-              this._pageMatchesLength.length = 0
-              this._matchesCountTotal = 0
-
-              this._updateAllPages()
-
-              for (let i = 0; i < numPages; i++) {
-                if (this._pendingFindMatches[i] === true) {
-                  continue
+                if (currentId > expectedId) {
+                  return expectedId - currentPageNumber;
                 }
-
-                this._pendingFindMatches[i] = true
-
-                this._extractTextPromises[i].then(pageIdx => {
-                  delete this._pendingFindMatches[pageIdx]
-
-                  this._calculateMatch(pageIdx)
-                })
               }
             }
 
-            if (this._query === '') {
-              this._updateUIState(FindState.FOUND)
-
-              return
-            }
-
-            if (this._resumePageIdx) {
-              return
-            }
-
-            const offset = this._offset
-            this._pagesToSearch = numPages
-
-            if (offset.matchIdx !== null) {
-              const numPageMatches = this._pageMatches[offset.pageIdx].length
-
-              if (!previous && offset.matchIdx + 1 < numPageMatches || previous && offset.matchIdx > 0) {
-                offset.matchIdx = previous ? offset.matchIdx - 1 : offset.matchIdx + 1
+            if (previous) {
+              const firstId = yArray[0];
 
-                this._updateMatch(true)
-
-                return
+              if (firstId < currentPageNumber) {
+                return currentPageNumber - firstId + 1;
               }
+            } else {
+              const lastId = yArray[numPages - 1];
 
-              this._advanceOffsetPage(previous)
-            }
-
-            this._nextPageMatch()
-          }
-
-          _matchesReady (matches) {
-            const offset = this._offset
-            const numMatches = matches.length
-            const previous = this._state.findPrevious
-
-            if (numMatches) {
-              offset.matchIdx = previous ? numMatches - 1 : 0
-
-              this._updateMatch(true)
-
-              return true
-            }
-
-            this._advanceOffsetPage(previous)
-
-            if (offset.wrapped) {
-              offset.matchIdx = null
-
-              if (this._pagesToSearch < 0) {
-                this._updateMatch(false)
-
-                return true
+              if (lastId > currentPageNumber) {
+                return lastId - currentPageNumber + 1;
               }
             }
 
-            return false
+            break;
           }
 
-          _nextPageMatch () {
-            if (this._resumePageIdx !== null) {
-              console.error('There can only be one pending page.')
-            }
-
-            let matches = null
-
-            do {
-              const pageIdx = this._offset.pageIdx
-              matches = this._pageMatches[pageIdx]
-
-              if (!matches) {
-                this._resumePageIdx = pageIdx
-                break
-              }
-            } while (!this._matchesReady(matches))
-          }
-
-          _advanceOffsetPage (previous) {
-            const offset = this._offset
-            const numPages = this._linkService.pagesCount
-            offset.pageIdx = previous ? offset.pageIdx - 1 : offset.pageIdx + 1
-            offset.matchIdx = null
-            this._pagesToSearch--
-
-            if (offset.pageIdx >= numPages || offset.pageIdx < 0) {
-              offset.pageIdx = previous ? numPages - 1 : 0
-              offset.wrapped = true
-            }
-          }
-
-          _updateMatch (found = false) {
-            let state = FindState.NOT_FOUND
-            const wrapped = this._offset.wrapped
-            this._offset.wrapped = false
-
-            if (found) {
-              const previousPage = this._selected.pageIdx
-              this._selected.pageIdx = this._offset.pageIdx
-              this._selected.matchIdx = this._offset.matchIdx
-              state = wrapped ? FindState.WRAPPED : FindState.FOUND
-
-              if (previousPage !== -1 && previousPage !== this._selected.pageIdx) {
-                this._updatePage(previousPage)
-              }
-            }
-
-            this._updateUIState(state, this._state.findPrevious)
+          break;
+        }
 
-            if (this._selected.pageIdx !== -1) {
-              this._scrollMatches = true
+      case _ui_utils.ScrollMode.HORIZONTAL:
+        {
+          break;
+        }
 
-              this._updatePage(this._selected.pageIdx)
-            }
+      case _ui_utils.ScrollMode.PAGE:
+      case _ui_utils.ScrollMode.VERTICAL:
+        {
+          if (this._spreadMode === _ui_utils.SpreadMode.NONE) {
+            break;
           }
 
-          _onFindBarClose (evt) {
-            const pdfDocument = this._pdfDocument
-
-            this._firstPageCapability.promise.then(() => {
-              if (!this._pdfDocument || pdfDocument && this._pdfDocument !== pdfDocument) {
-                return
-              }
-
-              if (this._findTimeout) {
-                clearTimeout(this._findTimeout)
-                this._findTimeout = null
-              }
-
-              if (this._resumePageIdx) {
-                this._resumePageIdx = null
-                this._dirtyMatch = true
-              }
-
-              this._updateUIState(FindState.FOUND)
+          const parity = this._spreadMode - 1;
 
-              this._highlightMatches = false
-
-              this._updateAllPages()
-            })
+          if (previous && currentPageNumber % 2 !== parity) {
+            break;
+          } else if (!previous && currentPageNumber % 2 === parity) {
+            break;
           }
 
-          _requestMatchesCount () {
-            const {
-              pageIdx,
-              matchIdx
-            } = this._selected
-            let current = 0,
-              total = this._matchesCountTotal
-
-            if (matchIdx !== -1) {
-              for (let i = 0; i < pageIdx; i++) {
-                current += this._pageMatches[i]?.length || 0
-              }
-
-              current += matchIdx + 1
-            }
+          const {
+            views
+          } = this._getVisiblePages(),
+                expectedId = previous ? currentPageNumber - 1 : currentPageNumber + 1;
 
-            if (current < 1 || current > total) {
-              current = total = 0
+          for (const {
+            id,
+            percent,
+            widthPercent
+          } of views) {
+            if (id !== expectedId) {
+              continue;
             }
 
-            return {
-              current,
-              total
+            if (percent > 0 && widthPercent === 100) {
+              return 2;
             }
-          }
-
-          _updateUIResultsCount () {
-            this._eventBus.dispatch('updatefindmatchescount', {
-              source: this,
-              matchesCount: this._requestMatchesCount()
-            })
-          }
 
-          _updateUIState (state, previous) {
-            this._eventBus.dispatch('updatefindcontrolstate', {
-              source: this,
-              state,
-              previous,
-              matchesCount: this._requestMatchesCount(),
-              rawQuery: this._state?.query ?? null
-            })
+            break;
           }
 
+          break;
         }
+    }
 
-        exports.PDFFindController = PDFFindController
-
-        /***/
-      }),
-      /* 12 */
-      /***/ ((__unused_webpack_module, exports) => {
-
-        Object.defineProperty(exports, '__esModule', ({
-          value: true
-        }))
-        exports.getCharacterType = getCharacterType
-        exports.CharacterType = void 0
-        const CharacterType = {
-          SPACE: 0,
-          ALPHA_LETTER: 1,
-          PUNCT: 2,
-          HAN_LETTER: 3,
-          KATAKANA_LETTER: 4,
-          HIRAGANA_LETTER: 5,
-          HALFWIDTH_KATAKANA_LETTER: 6,
-          THAI_LETTER: 7
-        }
-        exports.CharacterType = CharacterType
-
-        function isAlphabeticalScript (charCode) {
-          return charCode < 0x2e80
-        }
-
-        function isAscii (charCode) {
-          return (charCode & 0xff80) === 0
-        }
-
-        function isAsciiAlpha (charCode) {
-          return charCode >= 0x61 && charCode <= 0x7a || charCode >= 0x41 && charCode <= 0x5a
-        }
-
-        function isAsciiDigit (charCode) {
-          return charCode >= 0x30 && charCode <= 0x39
-        }
-
-        function isAsciiSpace (charCode) {
-          return charCode === 0x20 || charCode === 0x09 || charCode === 0x0d || charCode === 0x0a
-        }
-
-        function isHan (charCode) {
-          return charCode >= 0x3400 && charCode <= 0x9fff || charCode >= 0xf900 && charCode <= 0xfaff
-        }
-
-        function isKatakana (charCode) {
-          return charCode >= 0x30a0 && charCode <= 0x30ff
-        }
-
-        function isHiragana (charCode) {
-          return charCode >= 0x3040 && charCode <= 0x309f
-        }
-
-        function isHalfwidthKatakana (charCode) {
-          return charCode >= 0xff60 && charCode <= 0xff9f
-        }
-
-        function isThai (charCode) {
-          return (charCode & 0xff80) === 0x0e00
-        }
-
-        function getCharacterType (charCode) {
-          if (isAlphabeticalScript(charCode)) {
-            if (isAscii(charCode)) {
-              if (isAsciiSpace(charCode)) {
-                return CharacterType.SPACE
-              } else if (isAsciiAlpha(charCode) || isAsciiDigit(charCode) || charCode === 0x5f) {
-                return CharacterType.ALPHA_LETTER
-              }
+    return 1;
+  }
 
-              return CharacterType.PUNCT
-            } else if (isThai(charCode)) {
-              return CharacterType.THAI_LETTER
-            } else if (charCode === 0xa0) {
-              return CharacterType.SPACE
-            }
+  nextPage() {
+    const currentPageNumber = this._currentPageNumber,
+          pagesCount = this.pagesCount;
 
-            return CharacterType.ALPHA_LETTER
-          }
+    if (currentPageNumber >= pagesCount) {
+      return false;
+    }
 
-          if (isHan(charCode)) {
-            return CharacterType.HAN_LETTER
-          } else if (isKatakana(charCode)) {
-            return CharacterType.KATAKANA_LETTER
-          } else if (isHiragana(charCode)) {
-            return CharacterType.HIRAGANA_LETTER
-          } else if (isHalfwidthKatakana(charCode)) {
-            return CharacterType.HALFWIDTH_KATAKANA_LETTER
-          }
+    const advance = this._getPageAdvance(currentPageNumber, false) || 1;
+    this.currentPageNumber = Math.min(currentPageNumber + advance, pagesCount);
+    return true;
+  }
 
-          return CharacterType.ALPHA_LETTER
-        }
+  previousPage() {
+    const currentPageNumber = this._currentPageNumber;
 
-        /***/
-      }),
-      /* 13 */
-      /***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+    if (currentPageNumber <= 1) {
+      return false;
+    }
 
-        Object.defineProperty(exports, '__esModule', ({
-          value: true
-        }))
-        exports.isDestArraysEqual = isDestArraysEqual
-        exports.isDestHashesEqual = isDestHashesEqual
-        exports.PDFHistory = void 0
+    const advance = this._getPageAdvance(currentPageNumber, true) || 1;
+    this.currentPageNumber = Math.max(currentPageNumber - advance, 1);
+    return true;
+  }
 
-        var _ui_utils = __w_pdfjs_require__(5)
+  increaseScale(steps = 1) {
+    let newScale = this._currentScale;
 
-        const HASH_CHANGE_TIMEOUT = 1000
-        const POSITION_UPDATED_THRESHOLD = 50
-        const UPDATE_VIEWAREA_TIMEOUT = 1000
+    do {
+      newScale = (newScale * _ui_utils.DEFAULT_SCALE_DELTA).toFixed(2);
+      newScale = Math.ceil(newScale * 10) / 10;
+      newScale = Math.min(_ui_utils.MAX_SCALE, newScale);
+    } while (--steps > 0 && newScale < _ui_utils.MAX_SCALE);
 
-        function getCurrentHash () {
-          return document.location.hash
-        }
+    this.currentScaleValue = newScale;
+  }
 
-        class PDFHistory {
-          constructor ({
-            linkService,
-            eventBus
-          }) {
-            this.linkService = linkService
-            this.eventBus = eventBus
-            this._initialized = false
-            this._fingerprint = ''
-            this.reset()
-            this._boundEvents = null
-            this._isViewerInPresentationMode = false
-
-            this.eventBus._on('presentationmodechanged', evt => {
-              this._isViewerInPresentationMode = evt.state !== _ui_utils.PresentationModeState.NORMAL
-            })
-
-            this.eventBus._on('pagesinit', () => {
-              this._isPagesLoaded = false
-
-              this.eventBus._on('pagesloaded', evt => {
-                this._isPagesLoaded = !!evt.pagesCount
-              }, {
-                once: true
-              })
-            })
-          }
+  decreaseScale(steps = 1) {
+    let newScale = this._currentScale;
 
-          initialize ({
-            fingerprint,
-            resetHistory = false,
-            updateUrl = false
-          }) {
-            if (!fingerprint || typeof fingerprint !== 'string') {
-              console.error('PDFHistory.initialize: The "fingerprint" must be a non-empty string.')
-              return
-            }
+    do {
+      newScale = (newScale / _ui_utils.DEFAULT_SCALE_DELTA).toFixed(2);
+      newScale = Math.floor(newScale * 10) / 10;
+      newScale = Math.max(_ui_utils.MIN_SCALE, newScale);
+    } while (--steps > 0 && newScale > _ui_utils.MIN_SCALE);
 
-            if (this._initialized) {
-              this.reset()
-            }
+    this.currentScaleValue = newScale;
+  }
 
-            const reInitialized = this._fingerprint !== '' && this._fingerprint !== fingerprint
-            this._fingerprint = fingerprint
-            this._updateUrl = updateUrl === true
-            this._initialized = true
-
-            this._bindEvents()
-
-            const state = window.history.state
-            this._popStateInProgress = false
-            this._blockHashChange = 0
-            this._currentHash = getCurrentHash()
-            this._numPositionUpdates = 0
-            this._uid = this._maxUid = 0
-            this._destination = null
-            this._position = null
-
-            if (!this._isValidState(state, true) || resetHistory) {
-              const {
-                hash,
-                page,
-                rotation
-              } = this._parseCurrentHash(true)
-
-              if (!hash || reInitialized || resetHistory) {
-                this._pushOrReplaceState(null, true)
-
-                return
-              }
+  updateContainerHeightCss() {
+    const height = this.container.clientHeight;
 
-              this._pushOrReplaceState({
-                hash,
-                page,
-                rotation
-              }, true)
+    if (height !== this.#previousContainerHeight) {
+      this.#previousContainerHeight = height;
 
-              return
-            }
-
-            const destination = state.destination
+      this._doc.style.setProperty("--viewer-container-height", `${height}px`);
+    }
+  }
+
+}
+
+exports.BaseViewer = BaseViewer;
+
+/***/ }),
+/* 12 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDFPageView = void 0;
+
+var _pdfjsLib = __w_pdfjs_require__(3);
+
+var _ui_utils = __w_pdfjs_require__(6);
+
+var _app_options = __w_pdfjs_require__(13);
+
+var _l10n_utils = __w_pdfjs_require__(4);
+
+const MAX_CANVAS_PIXELS = _app_options.compatibilityParams.maxCanvasPixels || 16777216;
+
+class PDFPageView {
+  #annotationMode = _pdfjsLib.AnnotationMode.ENABLE_FORMS;
+
+  constructor(options) {
+    const container = options.container;
+    const defaultViewport = options.defaultViewport;
+    this.id = options.id;
+    this.renderingId = "page" + this.id;
+    this.pdfPage = null;
+    this.pageLabel = null;
+    this.rotation = 0;
+    this.scale = options.scale || _ui_utils.DEFAULT_SCALE;
+    this.viewport = defaultViewport;
+    this.pdfPageRotate = defaultViewport.rotation;
+    this._optionalContentConfigPromise = options.optionalContentConfigPromise || null;
+    this.hasRestrictedScaling = false;
+    this.textLayerMode = options.textLayerMode ?? _ui_utils.TextLayerMode.ENABLE;
+    this.#annotationMode = options.annotationMode ?? _pdfjsLib.AnnotationMode.ENABLE_FORMS;
+    this.imageResourcesPath = options.imageResourcesPath || "";
+    this.useOnlyCssZoom = options.useOnlyCssZoom || false;
+    this.maxCanvasPixels = options.maxCanvasPixels || MAX_CANVAS_PIXELS;
+    this.pageColors = options.pageColors || null;
+    this.eventBus = options.eventBus;
+    this.renderingQueue = options.renderingQueue;
+    this.textLayerFactory = options.textLayerFactory;
+    this.annotationLayerFactory = options.annotationLayerFactory;
+    this.xfaLayerFactory = options.xfaLayerFactory;
+    this.textHighlighter = options.textHighlighterFactory?.createTextHighlighter(this.id - 1, this.eventBus);
+    this.structTreeLayerFactory = options.structTreeLayerFactory;
+    this.renderer = options.renderer || _ui_utils.RendererType.CANVAS;
+    this.l10n = options.l10n || _l10n_utils.NullL10n;
+    this.paintTask = null;
+    this.paintedViewportMap = new WeakMap();
+    this.renderingState = _ui_utils.RenderingStates.INITIAL;
+    this.resume = null;
+    this._renderError = null;
+    this._isStandalone = !this.renderingQueue?.hasViewer();
+    this._annotationCanvasMap = null;
+    this.annotationLayer = null;
+    this.textLayer = null;
+    this.zoomLayer = null;
+    this.xfaLayer = null;
+    this.structTreeLayer = null;
+    const div = document.createElement("div");
+    div.className = "page";
+    div.style.width = Math.floor(this.viewport.width) + "px";
+    div.style.height = Math.floor(this.viewport.height) + "px";
+    div.setAttribute("data-page-number", this.id);
+    div.setAttribute("role", "region");
+    this.l10n.get("page_landmark", {
+      page: this.id
+    }).then(msg => {
+      div.setAttribute("aria-label", msg);
+    });
+    this.div = div;
+    container?.appendChild(div);
+  }
+
+  setPdfPage(pdfPage) {
+    this.pdfPage = pdfPage;
+    this.pdfPageRotate = pdfPage.rotate;
+    const totalRotation = (this.rotation + this.pdfPageRotate) % 360;
+    this.viewport = pdfPage.getViewport({
+      scale: this.scale * _pdfjsLib.PixelsPerInch.PDF_TO_CSS_UNITS,
+      rotation: totalRotation
+    });
+    this.reset();
+  }
+
+  destroy() {
+    this.reset();
+
+    if (this.pdfPage) {
+      this.pdfPage.cleanup();
+    }
+  }
+
+  async _renderAnnotationLayer() {
+    let error = null;
+
+    try {
+      await this.annotationLayer.render(this.viewport, "display");
+    } catch (ex) {
+      error = ex;
+    } finally {
+      this.eventBus.dispatch("annotationlayerrendered", {
+        source: this,
+        pageNumber: this.id,
+        error
+      });
+    }
+  }
 
-            this._updateInternalState(destination, state.uid, true)
+  async _renderXfaLayer() {
+    let error = null;
 
-            if (destination.rotation !== undefined) {
-              this._initialRotation = destination.rotation
-            }
+    try {
+      const result = await this.xfaLayer.render(this.viewport, "display");
 
-            if (destination.dest) {
-              this._initialBookmark = JSON.stringify(destination.dest)
-              this._destination.page = null
-            } else if (destination.hash) {
-              this._initialBookmark = destination.hash
-            } else if (destination.page) {
-              this._initialBookmark = `page=${destination.page}`
-            }
-          }
+      if (this.textHighlighter) {
+        this._buildXfaTextContentItems(result.textDivs);
+      }
+    } catch (ex) {
+      error = ex;
+    } finally {
+      this.eventBus.dispatch("xfalayerrendered", {
+        source: this,
+        pageNumber: this.id,
+        error
+      });
+    }
+  }
 
-          reset () {
-            if (this._initialized) {
-              this._pageHide()
+  async _buildXfaTextContentItems(textDivs) {
+    const text = await this.pdfPage.getTextContent();
+    const items = [];
 
-              this._initialized = false
+    for (const item of text.items) {
+      items.push(item.str);
+    }
 
-              this._unbindEvents()
-            }
+    this.textHighlighter.setTextMapping(textDivs, items);
+    this.textHighlighter.enable();
+  }
 
-            if (this._updateViewareaTimeout) {
-              clearTimeout(this._updateViewareaTimeout)
-              this._updateViewareaTimeout = null
-            }
+  _resetZoomLayer(removeFromDOM = false) {
+    if (!this.zoomLayer) {
+      return;
+    }
 
-            this._initialBookmark = null
-            this._initialRotation = null
-          }
+    const zoomLayerCanvas = this.zoomLayer.firstChild;
+    this.paintedViewportMap.delete(zoomLayerCanvas);
+    zoomLayerCanvas.width = 0;
+    zoomLayerCanvas.height = 0;
 
-          push ({
-            namedDest = null,
-            explicitDest,
-            pageNumber
-          }) {
-            if (!this._initialized) {
-              return
-            }
+    if (removeFromDOM) {
+      this.zoomLayer.remove();
+    }
 
-            if (namedDest && typeof namedDest !== 'string') {
-              console.error('PDFHistory.push: ' + `"${namedDest}" is not a valid namedDest parameter.`)
-              return
-            } else if (!Array.isArray(explicitDest)) {
-              console.error('PDFHistory.push: ' + `"${explicitDest}" is not a valid explicitDest parameter.`)
-              return
-            } else if (!this._isValidPage(pageNumber)) {
-              if (pageNumber !== null || this._destination) {
-                console.error('PDFHistory.push: ' + `"${pageNumber}" is not a valid pageNumber parameter.`)
-                return
-              }
-            }
+    this.zoomLayer = null;
+  }
+
+  reset({
+    keepZoomLayer = false,
+    keepAnnotationLayer = false,
+    keepXfaLayer = false
+  } = {}) {
+    this.cancelRendering({
+      keepAnnotationLayer,
+      keepXfaLayer
+    });
+    this.renderingState = _ui_utils.RenderingStates.INITIAL;
+    const div = this.div;
+    div.style.width = Math.floor(this.viewport.width) + "px";
+    div.style.height = Math.floor(this.viewport.height) + "px";
+    const childNodes = div.childNodes,
+          zoomLayerNode = keepZoomLayer && this.zoomLayer || null,
+          annotationLayerNode = keepAnnotationLayer && this.annotationLayer?.div || null,
+          xfaLayerNode = keepXfaLayer && this.xfaLayer?.div || null;
+
+    for (let i = childNodes.length - 1; i >= 0; i--) {
+      const node = childNodes[i];
+
+      switch (node) {
+        case zoomLayerNode:
+        case annotationLayerNode:
+        case xfaLayerNode:
+          continue;
+      }
 
-            const hash = namedDest || JSON.stringify(explicitDest)
+      node.remove();
+    }
 
-            if (!hash) {
-              return
-            }
+    div.removeAttribute("data-loaded");
 
-            let forceReplace = false
+    if (annotationLayerNode) {
+      this.annotationLayer.hide();
+    }
 
-            if (this._destination && (isDestHashesEqual(this._destination.hash, hash) || isDestArraysEqual(this._destination.dest, explicitDest))) {
-              if (this._destination.page) {
-                return
-              }
+    if (xfaLayerNode) {
+      this.xfaLayer.hide();
+    }
 
-              forceReplace = true
-            }
+    if (!zoomLayerNode) {
+      if (this.canvas) {
+        this.paintedViewportMap.delete(this.canvas);
+        this.canvas.width = 0;
+        this.canvas.height = 0;
+        delete this.canvas;
+      }
 
-            if (this._popStateInProgress && !forceReplace) {
-              return
-            }
+      this._resetZoomLayer();
+    }
 
-            this._pushOrReplaceState({
-              dest: explicitDest,
-              hash,
-              page: pageNumber,
-              rotation: this.linkService.rotation
-            }, forceReplace)
-
-            if (!this._popStateInProgress) {
-              this._popStateInProgress = true
-              Promise.resolve().then(() => {
-                this._popStateInProgress = false
-              })
-            }
-          }
+    if (this.svg) {
+      this.paintedViewportMap.delete(this.svg);
+      delete this.svg;
+    }
 
-          pushPage (pageNumber) {
-            if (!this._initialized) {
-              return
-            }
+    this.loadingIconDiv = document.createElement("div");
+    this.loadingIconDiv.className = "loadingIcon notVisible";
 
-            if (!this._isValidPage(pageNumber)) {
-              console.error(`PDFHistory.pushPage: "${pageNumber}" is not a valid page number.`)
-              return
-            }
+    if (this._isStandalone) {
+      this.toggleLoadingIconSpinner(true);
+    }
 
-            if (this._destination?.page === pageNumber) {
-              return
-            }
+    this.loadingIconDiv.setAttribute("role", "img");
+    this.l10n.get("loading").then(msg => {
+      this.loadingIconDiv?.setAttribute("aria-label", msg);
+    });
+    div.appendChild(this.loadingIconDiv);
+  }
+
+  update({
+    scale = 0,
+    rotation = null,
+    optionalContentConfigPromise = null
+  }) {
+    this.scale = scale || this.scale;
+
+    if (typeof rotation === "number") {
+      this.rotation = rotation;
+    }
 
-            if (this._popStateInProgress) {
-              return
-            }
+    if (optionalContentConfigPromise instanceof Promise) {
+      this._optionalContentConfigPromise = optionalContentConfigPromise;
+    }
 
-            this._pushOrReplaceState({
-              dest: null,
-              hash: `page=${pageNumber}`,
-              page: pageNumber,
-              rotation: this.linkService.rotation
-            })
-
-            if (!this._popStateInProgress) {
-              this._popStateInProgress = true
-              Promise.resolve().then(() => {
-                this._popStateInProgress = false
-              })
-            }
-          }
+    const totalRotation = (this.rotation + this.pdfPageRotate) % 360;
+    this.viewport = this.viewport.clone({
+      scale: this.scale * _pdfjsLib.PixelsPerInch.PDF_TO_CSS_UNITS,
+      rotation: totalRotation
+    });
+
+    if (this._isStandalone) {
+      const {
+        style
+      } = document.documentElement;
+      style.setProperty("--zoom-factor", this.scale);
+    }
 
-          pushCurrentPosition () {
-            if (!this._initialized || this._popStateInProgress) {
-              return
-            }
+    if (this.svg) {
+      this.cssTransform({
+        target: this.svg,
+        redrawAnnotationLayer: true,
+        redrawXfaLayer: true
+      });
+      this.eventBus.dispatch("pagerendered", {
+        source: this,
+        pageNumber: this.id,
+        cssTransform: true,
+        timestamp: performance.now(),
+        error: this._renderError
+      });
+      return;
+    }
 
-            this._tryPushCurrentPosition()
-          }
+    let isScalingRestricted = false;
 
-          back () {
-            if (!this._initialized || this._popStateInProgress) {
-              return
-            }
+    if (this.canvas && this.maxCanvasPixels > 0) {
+      const outputScale = this.outputScale;
 
-            const state = window.history.state
+      if ((Math.floor(this.viewport.width) * outputScale.sx | 0) * (Math.floor(this.viewport.height) * outputScale.sy | 0) > this.maxCanvasPixels) {
+        isScalingRestricted = true;
+      }
+    }
 
-            if (this._isValidState(state) && state.uid > 0) {
-              window.history.back()
-            }
-          }
+    if (this.canvas) {
+      if (this.useOnlyCssZoom || this.hasRestrictedScaling && isScalingRestricted) {
+        this.cssTransform({
+          target: this.canvas,
+          redrawAnnotationLayer: true,
+          redrawXfaLayer: true
+        });
+        this.eventBus.dispatch("pagerendered", {
+          source: this,
+          pageNumber: this.id,
+          cssTransform: true,
+          timestamp: performance.now(),
+          error: this._renderError
+        });
+        return;
+      }
 
-          forward () {
-            if (!this._initialized || this._popStateInProgress) {
-              return
-            }
+      if (!this.zoomLayer && !this.canvas.hidden) {
+        this.zoomLayer = this.canvas.parentNode;
+        this.zoomLayer.style.position = "absolute";
+      }
+    }
 
-            const state = window.history.state
+    if (this.zoomLayer) {
+      this.cssTransform({
+        target: this.zoomLayer.firstChild
+      });
+    }
 
-            if (this._isValidState(state) && state.uid < this._maxUid) {
-              window.history.forward()
-            }
-          }
+    this.reset({
+      keepZoomLayer: true,
+      keepAnnotationLayer: true,
+      keepXfaLayer: true
+    });
+  }
+
+  cancelRendering({
+    keepAnnotationLayer = false,
+    keepXfaLayer = false
+  } = {}) {
+    if (this.paintTask) {
+      this.paintTask.cancel();
+      this.paintTask = null;
+    }
 
-          get popStateInProgress () {
-            return this._initialized && (this._popStateInProgress || this._blockHashChange > 0)
-          }
+    this.resume = null;
 
-          get initialBookmark () {
-            return this._initialized ? this._initialBookmark : null
-          }
+    if (this.textLayer) {
+      this.textLayer.cancel();
+      this.textLayer = null;
+    }
 
-          get initialRotation () {
-            return this._initialized ? this._initialRotation : null
-          }
+    if (this.annotationLayer && (!keepAnnotationLayer || !this.annotationLayer.div)) {
+      this.annotationLayer.cancel();
+      this.annotationLayer = null;
+      this._annotationCanvasMap = null;
+    }
 
-          _pushOrReplaceState (destination, forceReplace = false) {
-            const shouldReplace = forceReplace || !this._destination
-            const newState = {
-              fingerprint: this._fingerprint,
-              uid: shouldReplace ? this._uid : this._uid + 1,
-              destination
-            }
+    if (this.xfaLayer && (!keepXfaLayer || !this.xfaLayer.div)) {
+      this.xfaLayer.cancel();
+      this.xfaLayer = null;
+      this.textHighlighter?.disable();
+    }
 
-            this._updateInternalState(destination, newState.uid)
+    if (this._onTextLayerRendered) {
+      this.eventBus._off("textlayerrendered", this._onTextLayerRendered);
 
-            let newUrl
+      this._onTextLayerRendered = null;
+    }
+  }
+
+  cssTransform({
+    target,
+    redrawAnnotationLayer = false,
+    redrawXfaLayer = false
+  }) {
+    const width = this.viewport.width;
+    const height = this.viewport.height;
+    const div = this.div;
+    target.style.width = target.parentNode.style.width = div.style.width = Math.floor(width) + "px";
+    target.style.height = target.parentNode.style.height = div.style.height = Math.floor(height) + "px";
+    const relativeRotation = this.viewport.rotation - this.paintedViewportMap.get(target).rotation;
+    const absRotation = Math.abs(relativeRotation);
+    let scaleX = 1,
+        scaleY = 1;
+
+    if (absRotation === 90 || absRotation === 270) {
+      scaleX = height / width;
+      scaleY = width / height;
+    }
 
-            if (this._updateUrl && destination?.hash) {
-              const baseUrl = document.location.href.split('#')[0]
+    target.style.transform = `rotate(${relativeRotation}deg) scale(${scaleX}, ${scaleY})`;
 
-              if (!baseUrl.startsWith('file://')) {
-                newUrl = `${baseUrl}#${destination.hash}`
-              }
-            }
+    if (this.textLayer) {
+      const textLayerViewport = this.textLayer.viewport;
+      const textRelativeRotation = this.viewport.rotation - textLayerViewport.rotation;
+      const textAbsRotation = Math.abs(textRelativeRotation);
+      let scale = width / textLayerViewport.width;
 
-            if (shouldReplace) {
-              window.history.replaceState(newState, '', newUrl)
-            } else {
-              window.history.pushState(newState, '', newUrl)
-            }
-          }
+      if (textAbsRotation === 90 || textAbsRotation === 270) {
+        scale = width / textLayerViewport.height;
+      }
 
-          _tryPushCurrentPosition (temporary = false) {
-            if (!this._position) {
-              return
-            }
+      const textLayerDiv = this.textLayer.textLayerDiv;
+      let transX, transY;
 
-            let position = this._position
+      switch (textAbsRotation) {
+        case 0:
+          transX = transY = 0;
+          break;
 
-            if (temporary) {
-              position = Object.assign(Object.create(null), this._position)
-              position.temporary = true
-            }
+        case 90:
+          transX = 0;
+          transY = "-" + textLayerDiv.style.height;
+          break;
 
-            if (!this._destination) {
-              this._pushOrReplaceState(position)
+        case 180:
+          transX = "-" + textLayerDiv.style.width;
+          transY = "-" + textLayerDiv.style.height;
+          break;
 
-              return
-            }
+        case 270:
+          transX = "-" + textLayerDiv.style.width;
+          transY = 0;
+          break;
 
-            if (this._destination.temporary) {
-              this._pushOrReplaceState(position, true)
+        default:
+          console.error("Bad rotation value.");
+          break;
+      }
 
-              return
-            }
+      textLayerDiv.style.transform = `rotate(${textAbsRotation}deg) ` + `scale(${scale}) ` + `translate(${transX}, ${transY})`;
+      textLayerDiv.style.transformOrigin = "0% 0%";
+    }
 
-            if (this._destination.hash === position.hash) {
-              return
-            }
+    if (redrawAnnotationLayer && this.annotationLayer) {
+      this._renderAnnotationLayer();
+    }
 
-            if (!this._destination.page && (POSITION_UPDATED_THRESHOLD <= 0 || this._numPositionUpdates <= POSITION_UPDATED_THRESHOLD)) {
-              return
-            }
+    if (redrawXfaLayer && this.xfaLayer) {
+      this._renderXfaLayer();
+    }
+  }
 
-            let forceReplace = false
+  get width() {
+    return this.viewport.width;
+  }
 
-            if (this._destination.page >= position.first && this._destination.page <= position.page) {
-              if (this._destination.dest !== undefined || !this._destination.first) {
-                return
-              }
+  get height() {
+    return this.viewport.height;
+  }
 
-              forceReplace = true
-            }
+  getPagePoint(x, y) {
+    return this.viewport.convertToPdfPoint(x, y);
+  }
 
-            this._pushOrReplaceState(position, forceReplace)
-          }
+  toggleLoadingIconSpinner(viewVisible = false) {
+    this.loadingIconDiv?.classList.toggle("notVisible", !viewVisible);
+  }
 
-          _isValidPage (val) {
-            return Number.isInteger(val) && val > 0 && val <= this.linkService.pagesCount
-          }
+  draw() {
+    if (this.renderingState !== _ui_utils.RenderingStates.INITIAL) {
+      console.error("Must be in new state before drawing");
+      this.reset();
+    }
 
-          _isValidState (state, checkReload = false) {
-            if (!state) {
-              return false
-            }
+    const {
+      div,
+      pdfPage
+    } = this;
 
-            if (state.fingerprint !== this._fingerprint) {
-              if (checkReload) {
-                if (typeof state.fingerprint !== 'string' || state.fingerprint.length !== this._fingerprint.length) {
-                  return false
-                }
+    if (!pdfPage) {
+      this.renderingState = _ui_utils.RenderingStates.FINISHED;
 
-                const [perfEntry] = performance.getEntriesByType('navigation')
+      if (this.loadingIconDiv) {
+        this.loadingIconDiv.remove();
+        delete this.loadingIconDiv;
+      }
 
-                if (perfEntry?.type !== 'reload') {
-                  return false
-                }
-              } else {
-                return false
-              }
-            }
+      return Promise.reject(new Error("pdfPage is not loaded"));
+    }
 
-            if (!Number.isInteger(state.uid) || state.uid < 0) {
-              return false
-            }
+    this.renderingState = _ui_utils.RenderingStates.RUNNING;
+    const canvasWrapper = document.createElement("div");
+    canvasWrapper.style.width = div.style.width;
+    canvasWrapper.style.height = div.style.height;
+    canvasWrapper.classList.add("canvasWrapper");
 
-            if (state.destination === null || typeof state.destination !== 'object') {
-              return false
-            }
+    if (this.annotationLayer?.div) {
+      div.insertBefore(canvasWrapper, this.annotationLayer.div);
+    } else {
+      div.appendChild(canvasWrapper);
+    }
 
-            return true
-          }
+    let textLayer = null;
 
-          _updateInternalState (destination, uid, removeTemporary = false) {
-            if (this._updateViewareaTimeout) {
-              clearTimeout(this._updateViewareaTimeout)
-              this._updateViewareaTimeout = null
-            }
+    if (this.textLayerMode !== _ui_utils.TextLayerMode.DISABLE && this.textLayerFactory) {
+      const textLayerDiv = document.createElement("div");
+      textLayerDiv.className = "textLayer";
+      textLayerDiv.style.width = canvasWrapper.style.width;
+      textLayerDiv.style.height = canvasWrapper.style.height;
 
-            if (removeTemporary && destination?.temporary) {
-              delete destination.temporary
-            }
+      if (this.annotationLayer?.div) {
+        div.insertBefore(textLayerDiv, this.annotationLayer.div);
+      } else {
+        div.appendChild(textLayerDiv);
+      }
 
-            this._destination = destination
-            this._uid = uid
-            this._maxUid = Math.max(this._maxUid, uid)
-            this._numPositionUpdates = 0
-          }
+      textLayer = this.textLayerFactory.createTextLayerBuilder(textLayerDiv, this.id - 1, this.viewport, this.textLayerMode === _ui_utils.TextLayerMode.ENABLE_ENHANCE, this.eventBus, this.textHighlighter);
+    }
 
-          _parseCurrentHash (checkNameddest = false) {
-            const hash = unescape(getCurrentHash()).substring(1)
-            const params = (0, _ui_utils.parseQueryString)(hash)
-            const nameddest = params.nameddest || ''
-            let page = params.page | 0
+    this.textLayer = textLayer;
 
-            if (!this._isValidPage(page) || checkNameddest && nameddest.length > 0) {
-              page = null
-            }
+    if (this.#annotationMode !== _pdfjsLib.AnnotationMode.DISABLE && this.annotationLayerFactory) {
+      this._annotationCanvasMap ||= new Map();
+      this.annotationLayer ||= this.annotationLayerFactory.createAnnotationLayerBuilder(div, pdfPage, null, this.imageResourcesPath, this.#annotationMode === _pdfjsLib.AnnotationMode.ENABLE_FORMS, this.l10n, null, null, null, null, this._annotationCanvasMap);
+    }
 
-            return {
-              hash,
-              page,
-              rotation: this.linkService.rotation
-            }
-          }
+    if (this.xfaLayer?.div) {
+      div.appendChild(this.xfaLayer.div);
+    }
 
-          _updateViewarea ({
-            location
-          }) {
-            if (this._updateViewareaTimeout) {
-              clearTimeout(this._updateViewareaTimeout)
-              this._updateViewareaTimeout = null
-            }
+    let renderContinueCallback = null;
 
-            this._position = {
-              hash: this._isViewerInPresentationMode ? `page=${location.pageNumber}` : location.pdfOpenParams.substring(1),
-              page: this.linkService.page,
-              first: location.pageNumber,
-              rotation: location.rotation
-            }
+    if (this.renderingQueue) {
+      renderContinueCallback = cont => {
+        if (!this.renderingQueue.isHighestPriority(this)) {
+          this.renderingState = _ui_utils.RenderingStates.PAUSED;
 
-            if (this._popStateInProgress) {
-              return
-            }
+          this.resume = () => {
+            this.renderingState = _ui_utils.RenderingStates.RUNNING;
+            cont();
+          };
 
-            if (POSITION_UPDATED_THRESHOLD > 0 && this._isPagesLoaded && this._destination && !this._destination.page) {
-              this._numPositionUpdates++
-            }
+          return;
+        }
 
-            if (UPDATE_VIEWAREA_TIMEOUT > 0) {
-              this._updateViewareaTimeout = setTimeout(() => {
-                if (!this._popStateInProgress) {
-                  this._tryPushCurrentPosition(true)
-                }
+        cont();
+      };
+    }
 
-                this._updateViewareaTimeout = null
-              }, UPDATE_VIEWAREA_TIMEOUT)
-            }
-          }
+    const finishPaintTask = async (error = null) => {
+      if (paintTask === this.paintTask) {
+        this.paintTask = null;
+      }
 
-          _popState ({
-            state
-          }) {
-            const newHash = getCurrentHash(),
-              hashChanged = this._currentHash !== newHash
-            this._currentHash = newHash
-
-            if (!state) {
-              this._uid++
-
-              const {
-                hash,
-                page,
-                rotation
-              } = this._parseCurrentHash()
-
-              this._pushOrReplaceState({
-                hash,
-                page,
-                rotation
-              }, true)
-
-              return
-            }
+      if (error instanceof _pdfjsLib.RenderingCancelledException) {
+        this._renderError = null;
+        return;
+      }
 
-            if (!this._isValidState(state)) {
-              return
-            }
+      this._renderError = error;
+      this.renderingState = _ui_utils.RenderingStates.FINISHED;
 
-            this._popStateInProgress = true
-
-            if (hashChanged) {
-              this._blockHashChange++;
-              (0, _ui_utils.waitOnEventOrTimeout)({
-                target: window,
-                name: 'hashchange',
-                delay: HASH_CHANGE_TIMEOUT
-              }).then(() => {
-                this._blockHashChange--
-              })
-            }
+      if (this.loadingIconDiv) {
+        this.loadingIconDiv.remove();
+        delete this.loadingIconDiv;
+      }
 
-            const destination = state.destination
+      this._resetZoomLayer(true);
 
-            this._updateInternalState(destination, state.uid, true)
+      this.eventBus.dispatch("pagerendered", {
+        source: this,
+        pageNumber: this.id,
+        cssTransform: false,
+        timestamp: performance.now(),
+        error: this._renderError
+      });
 
-            if ((0, _ui_utils.isValidRotation)(destination.rotation)) {
-              this.linkService.rotation = destination.rotation
-            }
+      if (error) {
+        throw error;
+      }
+    };
+
+    const paintTask = this.renderer === _ui_utils.RendererType.SVG ? this.paintOnSvg(canvasWrapper) : this.paintOnCanvas(canvasWrapper);
+    paintTask.onRenderContinue = renderContinueCallback;
+    this.paintTask = paintTask;
+    const resultPromise = paintTask.promise.then(() => {
+      return finishPaintTask(null).then(() => {
+        if (textLayer) {
+          const readableStream = pdfPage.streamTextContent({
+            includeMarkedContent: true
+          });
+          textLayer.setTextContentStream(readableStream);
+          textLayer.render();
+        }
 
-            if (destination.dest) {
-              this.linkService.goToDestination(destination.dest)
-            } else if (destination.hash) {
-              this.linkService.setHash(destination.hash)
-            } else if (destination.page) {
-              this.linkService.page = destination.page
-            }
+        if (this.annotationLayer) {
+          this._renderAnnotationLayer();
+        }
+      });
+    }, function (reason) {
+      return finishPaintTask(reason);
+    });
+
+    if (this.xfaLayerFactory) {
+      if (!this.xfaLayer) {
+        this.xfaLayer = this.xfaLayerFactory.createXfaLayerBuilder(div, pdfPage, null);
+      }
 
-            Promise.resolve().then(() => {
-              this._popStateInProgress = false
-            })
-          }
+      this._renderXfaLayer();
+    }
 
-          _pageHide () {
-            if (!this._destination || this._destination.temporary) {
-              this._tryPushCurrentPosition()
-            }
-          }
+    if (this.structTreeLayerFactory && this.textLayer && this.canvas) {
+      this._onTextLayerRendered = event => {
+        if (event.pageNumber !== this.id) {
+          return;
+        }
 
-          _bindEvents () {
-            if (this._boundEvents) {
-              return
-            }
+        this.eventBus._off("textlayerrendered", this._onTextLayerRendered);
 
-            this._boundEvents = {
-              updateViewarea: this._updateViewarea.bind(this),
-              popState: this._popState.bind(this),
-              pageHide: this._pageHide.bind(this)
-            }
+        this._onTextLayerRendered = null;
 
-            this.eventBus._on('updateviewarea', this._boundEvents.updateViewarea)
+        if (!this.canvas) {
+          return;
+        }
 
-            window.addEventListener('popstate', this._boundEvents.popState)
-            window.addEventListener('pagehide', this._boundEvents.pageHide)
+        this.pdfPage.getStructTree().then(tree => {
+          if (!tree) {
+            return;
           }
 
-          _unbindEvents () {
-            if (!this._boundEvents) {
-              return
-            }
-
-            this.eventBus._off('updateviewarea', this._boundEvents.updateViewarea)
-
-            window.removeEventListener('popstate', this._boundEvents.popState)
-            window.removeEventListener('pagehide', this._boundEvents.pageHide)
-            this._boundEvents = null
+          if (!this.canvas) {
+            return;
           }
 
-        }
+          const treeDom = this.structTreeLayer.render(tree);
+          treeDom.classList.add("structTree");
+          this.canvas.appendChild(treeDom);
+        });
+      };
 
-        exports.PDFHistory = PDFHistory
+      this.eventBus._on("textlayerrendered", this._onTextLayerRendered);
 
-        function isDestHashesEqual (destHash, pushHash) {
-          if (typeof destHash !== 'string' || typeof pushHash !== 'string') {
-            return false
-          }
+      this.structTreeLayer = this.structTreeLayerFactory.createStructTreeLayerBuilder(pdfPage);
+    }
 
-          if (destHash === pushHash) {
-            return true
-          }
+    div.setAttribute("data-loaded", true);
+    this.eventBus.dispatch("pagerender", {
+      source: this,
+      pageNumber: this.id
+    });
+    return resultPromise;
+  }
+
+  paintOnCanvas(canvasWrapper) {
+    const renderCapability = (0, _pdfjsLib.createPromiseCapability)();
+    const result = {
+      promise: renderCapability.promise,
+
+      onRenderContinue(cont) {
+        cont();
+      },
+
+      cancel() {
+        renderTask.cancel();
+      }
 
-          const {
-            nameddest
-          } = (0, _ui_utils.parseQueryString)(destHash)
+    };
+    const viewport = this.viewport;
+    const canvas = document.createElement("canvas");
+    canvas.hidden = true;
+    let isCanvasHidden = true;
 
-          if (nameddest === pushHash) {
-            return true
-          }
+    const showCanvas = function () {
+      if (isCanvasHidden) {
+        canvas.hidden = false;
+        isCanvasHidden = false;
+      }
+    };
+
+    canvasWrapper.appendChild(canvas);
+    this.canvas = canvas;
+    const ctx = canvas.getContext("2d", {
+      alpha: false
+    });
+    const outputScale = this.outputScale = new _ui_utils.OutputScale();
+
+    if (this.useOnlyCssZoom) {
+      const actualSizeViewport = viewport.clone({
+        scale: _pdfjsLib.PixelsPerInch.PDF_TO_CSS_UNITS
+      });
+      outputScale.sx *= actualSizeViewport.width / viewport.width;
+      outputScale.sy *= actualSizeViewport.height / viewport.height;
+    }
 
-          return false
-        }
+    if (this.maxCanvasPixels > 0) {
+      const pixelsInViewport = viewport.width * viewport.height;
+      const maxScale = Math.sqrt(this.maxCanvasPixels / pixelsInViewport);
 
-        function isDestArraysEqual (firstDest, secondDest) {
-          function isEntryEqual (first, second) {
-            if (typeof first !== typeof second) {
-              return false
-            }
+      if (outputScale.sx > maxScale || outputScale.sy > maxScale) {
+        outputScale.sx = maxScale;
+        outputScale.sy = maxScale;
+        this.hasRestrictedScaling = true;
+      } else {
+        this.hasRestrictedScaling = false;
+      }
+    }
 
-            if (Array.isArray(first) || Array.isArray(second)) {
-              return false
-            }
+    const sfx = (0, _ui_utils.approximateFraction)(outputScale.sx);
+    const sfy = (0, _ui_utils.approximateFraction)(outputScale.sy);
+    canvas.width = (0, _ui_utils.roundToDivide)(viewport.width * outputScale.sx, sfx[0]);
+    canvas.height = (0, _ui_utils.roundToDivide)(viewport.height * outputScale.sy, sfy[0]);
+    canvas.style.width = (0, _ui_utils.roundToDivide)(viewport.width, sfx[1]) + "px";
+    canvas.style.height = (0, _ui_utils.roundToDivide)(viewport.height, sfy[1]) + "px";
+    this.paintedViewportMap.set(canvas, viewport);
+    const transform = outputScale.scaled ? [outputScale.sx, 0, 0, outputScale.sy, 0, 0] : null;
+    const renderContext = {
+      canvasContext: ctx,
+      transform,
+      viewport: this.viewport,
+      annotationMode: this.#annotationMode,
+      optionalContentConfigPromise: this._optionalContentConfigPromise,
+      annotationCanvasMap: this._annotationCanvasMap,
+      pageColors: this.pageColors
+    };
+    const renderTask = this.pdfPage.render(renderContext);
+
+    renderTask.onContinue = function (cont) {
+      showCanvas();
+
+      if (result.onRenderContinue) {
+        result.onRenderContinue(cont);
+      } else {
+        cont();
+      }
+    };
+
+    renderTask.promise.then(function () {
+      showCanvas();
+      renderCapability.resolve();
+    }, function (error) {
+      showCanvas();
+      renderCapability.reject(error);
+    });
+    return result;
+  }
+
+  paintOnSvg(wrapper) {
+    let cancelled = false;
+
+    const ensureNotCancelled = () => {
+      if (cancelled) {
+        throw new _pdfjsLib.RenderingCancelledException(`Rendering cancelled, page ${this.id}`, "svg");
+      }
+    };
+
+    const pdfPage = this.pdfPage;
+    const actualSizeViewport = this.viewport.clone({
+      scale: _pdfjsLib.PixelsPerInch.PDF_TO_CSS_UNITS
+    });
+    const promise = pdfPage.getOperatorList({
+      annotationMode: this.#annotationMode
+    }).then(opList => {
+      ensureNotCancelled();
+      const svgGfx = new _pdfjsLib.SVGGraphics(pdfPage.commonObjs, pdfPage.objs);
+      return svgGfx.getSVG(opList, actualSizeViewport).then(svg => {
+        ensureNotCancelled();
+        this.svg = svg;
+        this.paintedViewportMap.set(svg, actualSizeViewport);
+        svg.style.width = wrapper.style.width;
+        svg.style.height = wrapper.style.height;
+        this.renderingState = _ui_utils.RenderingStates.FINISHED;
+        wrapper.appendChild(svg);
+      });
+    });
+    return {
+      promise,
+
+      onRenderContinue(cont) {
+        cont();
+      },
+
+      cancel() {
+        cancelled = true;
+      }
 
-            if (first !== null && typeof first === 'object' && second !== null) {
-              if (Object.keys(first).length !== Object.keys(second).length) {
-                return false
-              }
+    };
+  }
 
-              for (const key in first) {
-                if (!isEntryEqual(first[key], second[key])) {
-                  return false
-                }
-              }
+  setPageLabel(label) {
+    this.pageLabel = typeof label === "string" ? label : null;
 
-              return true
-            }
+    if (this.pageLabel !== null) {
+      this.div.setAttribute("data-page-label", this.pageLabel);
+    } else {
+      this.div.removeAttribute("data-page-label");
+    }
+  }
 
-            return first === second || Number.isNaN(first) && Number.isNaN(second)
-          }
+}
 
-          if (!(Array.isArray(firstDest) && Array.isArray(secondDest))) {
-            return false
-          }
+exports.PDFPageView = PDFPageView;
 
-          if (firstDest.length !== secondDest.length) {
-            return false
-          }
+/***/ }),
+/* 13 */
+/***/ ((__unused_webpack_module, exports) => {
 
-          for (let i = 0, ii = firstDest.length; i < ii; i++) {
-            if (!isEntryEqual(firstDest[i], secondDest[i])) {
-              return false
-            }
-          }
 
-          return true
-        }
 
-        /***/
-      }),
-      /* 14 */
-      /***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
-
-        Object.defineProperty(exports, '__esModule', ({
-          value: true
-        }))
-        exports.PDFPageView = void 0
-
-        var _ui_utils = __w_pdfjs_require__(5)
-
-        var _pdfjsLib = __w_pdfjs_require__(2)
-
-        var _l10n_utils = __w_pdfjs_require__(3)
-
-        var _pdf_rendering_queue = __w_pdfjs_require__(15)
-
-        var _viewer_compatibility = __w_pdfjs_require__(8)
-
-        const MAX_CANVAS_PIXELS = _viewer_compatibility.viewerCompatibilityParams.maxCanvasPixels || 16777216
-
-        class PDFPageView {
-          constructor (options) {
-            const container = options.container
-            const defaultViewport = options.defaultViewport
-            this.id = options.id
-            this.renderingId = 'page' + this.id
-            this.pdfPage = null
-            this.pageLabel = null
-            this.rotation = 0
-            this.scale = options.scale || _ui_utils.DEFAULT_SCALE
-            this.viewport = defaultViewport
-            this.pdfPageRotate = defaultViewport.rotation
-            this._optionalContentConfigPromise = options.optionalContentConfigPromise || null
-            this.hasRestrictedScaling = false
-            this.textLayerMode = Number.isInteger(options.textLayerMode) ? options.textLayerMode : _ui_utils.TextLayerMode.ENABLE
-            this.imageResourcesPath = options.imageResourcesPath || ''
-            this.renderInteractiveForms = options.renderInteractiveForms !== false
-            this.useOnlyCssZoom = options.useOnlyCssZoom || false
-            this.maxCanvasPixels = options.maxCanvasPixels || MAX_CANVAS_PIXELS
-            this.eventBus = options.eventBus
-            this.renderingQueue = options.renderingQueue
-            this.textLayerFactory = options.textLayerFactory
-            this.annotationLayerFactory = options.annotationLayerFactory
-            this.xfaLayerFactory = options.xfaLayerFactory
-            this.renderer = options.renderer || _ui_utils.RendererType.CANVAS
-            this.enableWebGL = options.enableWebGL || false
-            this.l10n = options.l10n || _l10n_utils.NullL10n
-            this.enableScripting = options.enableScripting === true
-            this.paintTask = null
-            this.paintedViewportMap = new WeakMap()
-            this.renderingState = _pdf_rendering_queue.RenderingStates.INITIAL
-            this.resume = null
-            this._renderError = null
-            this.annotationLayer = null
-            this.textLayer = null
-            this.zoomLayer = null
-            this.xfaLayer = null
-            const div = document.createElement('div')
-            div.className = 'page'
-            div.style.width = Math.floor(this.viewport.width) + 'px'
-            div.style.height = Math.floor(this.viewport.height) + 'px'
-            div.setAttribute('data-page-number', this.id)
-            div.setAttribute('role', 'region')
-            this.l10n.get('page_landmark', {
-              page: this.id
-            }).then(msg => {
-              div.setAttribute('aria-label', msg)
-            })
-            this.div = div
-            container.appendChild(div)
-          }
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.compatibilityParams = exports.OptionKind = exports.AppOptions = void 0;
+const compatibilityParams = Object.create(null);
+exports.compatibilityParams = compatibilityParams;
+{
+  const userAgent = navigator.userAgent || "";
+  const platform = navigator.platform || "";
+  const maxTouchPoints = navigator.maxTouchPoints || 1;
+  const isAndroid = /Android/.test(userAgent);
+  const isIOS = /\b(iPad|iPhone|iPod)(?=;)/.test(userAgent) || platform === "MacIntel" && maxTouchPoints > 1;
 
-          setPdfPage (pdfPage) {
-            this.pdfPage = pdfPage
-            this.pdfPageRotate = pdfPage.rotate
-            const totalRotation = (this.rotation + this.pdfPageRotate) % 360
-            this.viewport = pdfPage.getViewport({
-              scale: this.scale * _ui_utils.CSS_UNITS,
-              rotation: totalRotation
-            })
-            this.reset()
-          }
+  (function checkCanvasSizeLimitation() {
+    if (isIOS || isAndroid) {
+      compatibilityParams.maxCanvasPixels = 5242880;
+    }
+  })();
+}
+const OptionKind = {
+  VIEWER: 0x02,
+  API: 0x04,
+  WORKER: 0x08,
+  PREFERENCE: 0x80
+};
+exports.OptionKind = OptionKind;
+const defaultOptions = {
+  annotationMode: {
+    value: 2,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  cursorToolOnLoad: {
+    value: 0,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  defaultUrl: {
+    value: "compressed.tracemonkey-pldi-09.pdf",
+    kind: OptionKind.VIEWER
+  },
+  defaultZoomValue: {
+    value: "",
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  disableHistory: {
+    value: false,
+    kind: OptionKind.VIEWER
+  },
+  disablePageLabels: {
+    value: false,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  enablePermissions: {
+    value: false,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  enablePrintAutoRotate: {
+    value: true,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  enableScripting: {
+    value: true,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  externalLinkRel: {
+    value: "noopener noreferrer nofollow",
+    kind: OptionKind.VIEWER
+  },
+  externalLinkTarget: {
+    value: 0,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  historyUpdateUrl: {
+    value: false,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  ignoreDestinationZoom: {
+    value: false,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  imageResourcesPath: {
+    value: "./images/",
+    kind: OptionKind.VIEWER
+  },
+  maxCanvasPixels: {
+    value: 16777216,
+    compatibility: compatibilityParams.maxCanvasPixels,
+    kind: OptionKind.VIEWER
+  },
+  pageColorsBackground: {
+    value: "Canvas",
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  pageColorsForeground: {
+    value: "CanvasText",
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  pdfBugEnabled: {
+    value: false,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  printResolution: {
+    value: 150,
+    kind: OptionKind.VIEWER
+  },
+  renderer: {
+    value: "canvas",
+    kind: OptionKind.VIEWER
+  },
+  sidebarViewOnLoad: {
+    value: -1,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  scrollModeOnLoad: {
+    value: -1,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  spreadModeOnLoad: {
+    value: -1,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  textLayerMode: {
+    value: 1,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  useOnlyCssZoom: {
+    value: false,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  viewerCssTheme: {
+    value: 0,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  viewOnLoad: {
+    value: 0,
+    kind: OptionKind.VIEWER + OptionKind.PREFERENCE
+  },
+  cMapPacked: {
+    value: true,
+    kind: OptionKind.API
+  },
+  cMapUrl: {
+    value: "../web/cmaps/",
+    kind: OptionKind.API
+  },
+  disableAutoFetch: {
+    value: false,
+    kind: OptionKind.API + OptionKind.PREFERENCE
+  },
+  disableFontFace: {
+    value: false,
+    kind: OptionKind.API + OptionKind.PREFERENCE
+  },
+  disableRange: {
+    value: false,
+    kind: OptionKind.API + OptionKind.PREFERENCE
+  },
+  disableStream: {
+    value: false,
+    kind: OptionKind.API + OptionKind.PREFERENCE
+  },
+  docBaseUrl: {
+    value: "",
+    kind: OptionKind.API
+  },
+  enableXfa: {
+    value: true,
+    kind: OptionKind.API + OptionKind.PREFERENCE
+  },
+  fontExtraProperties: {
+    value: false,
+    kind: OptionKind.API
+  },
+  isEvalSupported: {
+    value: true,
+    kind: OptionKind.API
+  },
+  maxImageSize: {
+    value: -1,
+    kind: OptionKind.API
+  },
+  pdfBug: {
+    value: false,
+    kind: OptionKind.API
+  },
+  standardFontDataUrl: {
+    value: "../web/standard_fonts/",
+    kind: OptionKind.API
+  },
+  verbosity: {
+    value: 1,
+    kind: OptionKind.API
+  },
+  workerPort: {
+    value: null,
+    kind: OptionKind.WORKER
+  },
+  workerSrc: {
+    value: "../build/pdf.worker.js",
+    kind: OptionKind.WORKER
+  }
+};
+{
+  defaultOptions.disablePreferences = {
+    value: false,
+    kind: OptionKind.VIEWER
+  };
+  defaultOptions.locale = {
+    value: navigator.language || "en-US",
+    kind: OptionKind.VIEWER
+  };
+  defaultOptions.sandboxBundleSrc = {
+    value: "../build/pdf.sandbox.js",
+    kind: OptionKind.VIEWER
+  };
+  defaultOptions.renderer.kind += OptionKind.PREFERENCE;
+}
+const userOptions = Object.create(null);
+
+class AppOptions {
+  constructor() {
+    throw new Error("Cannot initialize AppOptions.");
+  }
+
+  static get(name) {
+    const userOption = userOptions[name];
+
+    if (userOption !== undefined) {
+      return userOption;
+    }
 
-          destroy () {
-            this.reset()
+    const defaultOption = defaultOptions[name];
 
-            if (this.pdfPage) {
-              this.pdfPage.cleanup()
-            }
-          }
+    if (defaultOption !== undefined) {
+      return defaultOption.compatibility ?? defaultOption.value;
+    }
 
-          async _renderAnnotationLayer () {
-            let error = null
-
-            try {
-              await this.annotationLayer.render(this.viewport, 'display')
-            } catch (ex) {
-              error = ex
-            } finally {
-              this.eventBus.dispatch('annotationlayerrendered', {
-                source: this,
-                pageNumber: this.id,
-                error
-              })
-            }
-          }
+    return undefined;
+  }
 
-          async _renderXfaLayer () {
-            let error = null
-
-            try {
-              await this.xfaLayer.render(this.viewport, 'display')
-            } catch (ex) {
-              error = ex
-            } finally {
-              this.eventBus.dispatch('xfalayerrendered', {
-                source: this,
-                pageNumber: this.id,
-                error
-              })
-            }
-          }
+  static getAll(kind = null) {
+    const options = Object.create(null);
 
-          _resetZoomLayer (removeFromDOM = false) {
-            if (!this.zoomLayer) {
-              return
-            }
+    for (const name in defaultOptions) {
+      const defaultOption = defaultOptions[name];
 
-            const zoomLayerCanvas = this.zoomLayer.firstChild
-            this.paintedViewportMap.delete(zoomLayerCanvas)
-            zoomLayerCanvas.width = 0
-            zoomLayerCanvas.height = 0
+      if (kind) {
+        if ((kind & defaultOption.kind) === 0) {
+          continue;
+        }
 
-            if (removeFromDOM) {
-              this.zoomLayer.remove()
-            }
+        if (kind === OptionKind.PREFERENCE) {
+          const value = defaultOption.value,
+                valueType = typeof value;
 
-            this.zoomLayer = null
+          if (valueType === "boolean" || valueType === "string" || valueType === "number" && Number.isInteger(value)) {
+            options[name] = value;
+            continue;
           }
 
-          reset (keepZoomLayer = false, keepAnnotations = false) {
-            this.cancelRendering(keepAnnotations)
-            this.renderingState = _pdf_rendering_queue.RenderingStates.INITIAL
-            const div = this.div
-            div.style.width = Math.floor(this.viewport.width) + 'px'
-            div.style.height = Math.floor(this.viewport.height) + 'px'
-            const childNodes = div.childNodes
-            const currentZoomLayerNode = keepZoomLayer && this.zoomLayer || null
-            const currentAnnotationNode = keepAnnotations && this.annotationLayer?.div || null
-            const currentXfaLayerNode = this.xfaLayer?.div || null
-
-            for (let i = childNodes.length - 1; i >= 0; i--) {
-              const node = childNodes[i]
-
-              if (currentZoomLayerNode === node || currentAnnotationNode === node || currentXfaLayerNode === node) {
-                continue
-              }
-
-              div.removeChild(node)
-            }
+          throw new Error(`Invalid type for preference: ${name}`);
+        }
+      }
 
-            div.removeAttribute('data-loaded')
+      const userOption = userOptions[name];
+      options[name] = userOption !== undefined ? userOption : defaultOption.compatibility ?? defaultOption.value;
+    }
 
-            if (currentAnnotationNode) {
-              this.annotationLayer.hide()
-            } else if (this.annotationLayer) {
-              this.annotationLayer.cancel()
-              this.annotationLayer = null
-            }
+    return options;
+  }
 
-            if (!currentZoomLayerNode) {
-              if (this.canvas) {
-                this.paintedViewportMap.delete(this.canvas)
-                this.canvas.width = 0
-                this.canvas.height = 0
-                delete this.canvas
-              }
+  static set(name, value) {
+    userOptions[name] = value;
+  }
 
-              this._resetZoomLayer()
-            }
+  static setAll(options) {
+    for (const name in options) {
+      userOptions[name] = options[name];
+    }
+  }
 
-            if (this.svg) {
-              this.paintedViewportMap.delete(this.svg)
-              delete this.svg
-            }
+  static remove(name) {
+    delete userOptions[name];
+  }
 
-            this.loadingIconDiv = document.createElement('div')
-            this.loadingIconDiv.className = 'loadingIcon'
-            this.loadingIconDiv.setAttribute('role', 'img')
-            this.l10n.get('loading').then(msg => {
-              this.loadingIconDiv?.setAttribute('aria-label', msg)
-            })
-            div.appendChild(this.loadingIconDiv)
-          }
+  static _hasUserOptions() {
+    return Object.keys(userOptions).length > 0;
+  }
 
-          update (scale, rotation, optionalContentConfigPromise = null) {
-            this.scale = scale || this.scale
+}
 
-            if (typeof rotation !== 'undefined') {
-              this.rotation = rotation
-            }
+exports.AppOptions = AppOptions;
 
-            if (optionalContentConfigPromise instanceof Promise) {
-              this._optionalContentConfigPromise = optionalContentConfigPromise
-            }
+/***/ }),
+/* 14 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
 
-            const totalRotation = (this.rotation + this.pdfPageRotate) % 360
-            this.viewport = this.viewport.clone({
-              scale: this.scale * _ui_utils.CSS_UNITS,
-              rotation: totalRotation
-            })
-
-            if (this.svg) {
-              this.cssTransform(this.svg, true)
-              this.eventBus.dispatch('pagerendered', {
-                source: this,
-                pageNumber: this.id,
-                cssTransform: true,
-                timestamp: performance.now(),
-                error: this._renderError
-              })
-              return
-            }
 
-            let isScalingRestricted = false
 
-            if (this.canvas && this.maxCanvasPixels > 0) {
-              const outputScale = this.outputScale
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDFRenderingQueue = void 0;
 
-              if ((Math.floor(this.viewport.width) * outputScale.sx | 0) * (Math.floor(this.viewport.height) * outputScale.sy | 0) > this.maxCanvasPixels) {
-                isScalingRestricted = true
-              }
-            }
+var _pdfjsLib = __w_pdfjs_require__(3);
 
-            if (this.canvas) {
-              if (this.useOnlyCssZoom || this.hasRestrictedScaling && isScalingRestricted) {
-                this.cssTransform(this.canvas, true)
-                this.eventBus.dispatch('pagerendered', {
-                  source: this,
-                  pageNumber: this.id,
-                  cssTransform: true,
-                  timestamp: performance.now(),
-                  error: this._renderError
-                })
-                return
-              }
+var _ui_utils = __w_pdfjs_require__(6);
 
-              if (!this.zoomLayer && !this.canvas.hidden) {
-                this.zoomLayer = this.canvas.parentNode
-                this.zoomLayer.style.position = 'absolute'
-              }
-            }
+const CLEANUP_TIMEOUT = 30000;
 
-            if (this.zoomLayer) {
-              this.cssTransform(this.zoomLayer.firstChild)
-            }
+class PDFRenderingQueue {
+  constructor() {
+    this.pdfViewer = null;
+    this.pdfThumbnailViewer = null;
+    this.onIdle = null;
+    this.highestPriorityPage = null;
+    this.idleTimeout = null;
+    this.printing = false;
+    this.isThumbnailViewEnabled = false;
+  }
 
-            this.reset(true, true)
-          }
+  setViewer(pdfViewer) {
+    this.pdfViewer = pdfViewer;
+  }
 
-          cancelRendering (keepAnnotations = false) {
-            if (this.paintTask) {
-              this.paintTask.cancel()
-              this.paintTask = null
-            }
+  setThumbnailViewer(pdfThumbnailViewer) {
+    this.pdfThumbnailViewer = pdfThumbnailViewer;
+  }
 
-            this.resume = null
+  isHighestPriority(view) {
+    return this.highestPriorityPage === view.renderingId;
+  }
 
-            if (this.textLayer) {
-              this.textLayer.cancel()
-              this.textLayer = null
-            }
+  hasViewer() {
+    return !!this.pdfViewer;
+  }
 
-            if (!keepAnnotations && this.annotationLayer) {
-              this.annotationLayer.cancel()
-              this.annotationLayer = null
-            }
-          }
+  renderHighestPriority(currentlyVisiblePages) {
+    if (this.idleTimeout) {
+      clearTimeout(this.idleTimeout);
+      this.idleTimeout = null;
+    }
 
-          cssTransform (target, redrawAnnotations = false) {
-            const width = this.viewport.width
-            const height = this.viewport.height
-            const div = this.div
-            target.style.width = target.parentNode.style.width = div.style.width = Math.floor(width) + 'px'
-            target.style.height = target.parentNode.style.height = div.style.height = Math.floor(height) + 'px'
-            const relativeRotation = this.viewport.rotation - this.paintedViewportMap.get(target).rotation
-            const absRotation = Math.abs(relativeRotation)
-            let scaleX = 1,
-              scaleY = 1
-
-            if (absRotation === 90 || absRotation === 270) {
-              scaleX = height / width
-              scaleY = width / height
-            }
+    if (this.pdfViewer.forceRendering(currentlyVisiblePages)) {
+      return;
+    }
 
-            target.style.transform = `rotate(${relativeRotation}deg) scale(${scaleX}, ${scaleY})`
+    if (this.isThumbnailViewEnabled && this.pdfThumbnailViewer?.forceRendering()) {
+      return;
+    }
 
-            if (this.textLayer) {
-              const textLayerViewport = this.textLayer.viewport
-              const textRelativeRotation = this.viewport.rotation - textLayerViewport.rotation
-              const textAbsRotation = Math.abs(textRelativeRotation)
-              let scale = width / textLayerViewport.width
+    if (this.printing) {
+      return;
+    }
 
-              if (textAbsRotation === 90 || textAbsRotation === 270) {
-                scale = width / textLayerViewport.height
-              }
+    if (this.onIdle) {
+      this.idleTimeout = setTimeout(this.onIdle.bind(this), CLEANUP_TIMEOUT);
+    }
+  }
 
-              const textLayerDiv = this.textLayer.textLayerDiv
-              let transX, transY
+  getHighestPriority(visible, views, scrolledDown, preRenderExtra = false) {
+    const visibleViews = visible.views,
+          numVisible = visibleViews.length;
 
-              switch (textAbsRotation) {
-                case 0:
-                  transX = transY = 0
-                  break
+    if (numVisible === 0) {
+      return null;
+    }
 
-                case 90:
-                  transX = 0
-                  transY = '-' + textLayerDiv.style.height
-                  break
+    for (let i = 0; i < numVisible; i++) {
+      const view = visibleViews[i].view;
 
-                case 180:
-                  transX = '-' + textLayerDiv.style.width
-                  transY = '-' + textLayerDiv.style.height
-                  break
+      if (!this.isViewFinished(view)) {
+        return view;
+      }
+    }
 
-                case 270:
-                  transX = '-' + textLayerDiv.style.width
-                  transY = 0
-                  break
+    const firstId = visible.first.id,
+          lastId = visible.last.id;
 
-                default:
-                  console.error('Bad rotation value.')
-                  break
-              }
+    if (lastId - firstId + 1 > numVisible) {
+      const visibleIds = visible.ids;
 
-              textLayerDiv.style.transform = `rotate(${textAbsRotation}deg) ` + `scale(${scale}) ` + `translate(${transX}, ${transY})`
-              textLayerDiv.style.transformOrigin = '0% 0%'
-            }
+      for (let i = 1, ii = lastId - firstId; i < ii; i++) {
+        const holeId = scrolledDown ? firstId + i : lastId - i;
 
-            if (redrawAnnotations && this.annotationLayer) {
-              this._renderAnnotationLayer()
-            }
+        if (visibleIds.has(holeId)) {
+          continue;
+        }
 
-            if (this.xfaLayer) {
-              this._renderXfaLayer()
-            }
-          }
+        const holeView = views[holeId - 1];
 
-          get width () {
-            return this.viewport.width
-          }
+        if (!this.isViewFinished(holeView)) {
+          return holeView;
+        }
+      }
+    }
 
-          get height () {
-            return this.viewport.height
-          }
+    let preRenderIndex = scrolledDown ? lastId : firstId - 2;
+    let preRenderView = views[preRenderIndex];
 
-          getPagePoint (x, y) {
-            return this.viewport.convertToPdfPoint(x, y)
-          }
+    if (preRenderView && !this.isViewFinished(preRenderView)) {
+      return preRenderView;
+    }
 
-          draw () {
-            if (this.renderingState !== _pdf_rendering_queue.RenderingStates.INITIAL) {
-              console.error('Must be in new state before drawing')
-              this.reset()
-            }
+    if (preRenderExtra) {
+      preRenderIndex += scrolledDown ? 1 : -1;
+      preRenderView = views[preRenderIndex];
 
-            const {
-              div,
-              pdfPage
-            } = this
+      if (preRenderView && !this.isViewFinished(preRenderView)) {
+        return preRenderView;
+      }
+    }
 
-            if (!pdfPage) {
-              this.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED
+    return null;
+  }
 
-              if (this.loadingIconDiv) {
-                div.removeChild(this.loadingIconDiv)
-                delete this.loadingIconDiv
-              }
+  isViewFinished(view) {
+    return view.renderingState === _ui_utils.RenderingStates.FINISHED;
+  }
 
-              return Promise.reject(new Error('pdfPage is not loaded'))
-            }
+  renderView(view) {
+    switch (view.renderingState) {
+      case _ui_utils.RenderingStates.FINISHED:
+        return false;
 
-            this.renderingState = _pdf_rendering_queue.RenderingStates.RUNNING
-            const canvasWrapper = document.createElement('div')
-            canvasWrapper.style.width = div.style.width
-            canvasWrapper.style.height = div.style.height
-            canvasWrapper.classList.add('canvasWrapper')
+      case _ui_utils.RenderingStates.PAUSED:
+        this.highestPriorityPage = view.renderingId;
+        view.resume();
+        break;
 
-            if (this.annotationLayer?.div) {
-              div.insertBefore(canvasWrapper, this.annotationLayer.div)
-            } else {
-              div.appendChild(canvasWrapper)
-            }
+      case _ui_utils.RenderingStates.RUNNING:
+        this.highestPriorityPage = view.renderingId;
+        break;
 
-            let textLayer = null
+      case _ui_utils.RenderingStates.INITIAL:
+        this.highestPriorityPage = view.renderingId;
+        view.draw().finally(() => {
+          this.renderHighestPriority();
+        }).catch(reason => {
+          if (reason instanceof _pdfjsLib.RenderingCancelledException) {
+            return;
+          }
 
-            if (this.textLayerMode !== _ui_utils.TextLayerMode.DISABLE && this.textLayerFactory) {
-              const textLayerDiv = document.createElement('div')
-              textLayerDiv.className = 'textLayer'
-              textLayerDiv.style.width = canvasWrapper.style.width
-              textLayerDiv.style.height = canvasWrapper.style.height
+          console.error(`renderView: "${reason}"`);
+        });
+        break;
+    }
 
-              if (this.annotationLayer?.div) {
-                div.insertBefore(textLayerDiv, this.annotationLayer.div)
-              } else {
-                div.appendChild(textLayerDiv)
-              }
+    return true;
+  }
 
-              textLayer = this.textLayerFactory.createTextLayerBuilder(textLayerDiv, this.id - 1, this.viewport, this.textLayerMode === _ui_utils.TextLayerMode.ENABLE_ENHANCE, this.eventBus)
-            }
+}
 
-            this.textLayer = textLayer
-            let renderContinueCallback = null
+exports.PDFRenderingQueue = PDFRenderingQueue;
 
-            if (this.renderingQueue) {
-              renderContinueCallback = cont => {
-                if (!this.renderingQueue.isHighestPriority(this)) {
-                  this.renderingState = _pdf_rendering_queue.RenderingStates.PAUSED
+/***/ }),
+/* 15 */
+/***/ ((__unused_webpack_module, exports) => {
 
-                  this.resume = () => {
-                    this.renderingState = _pdf_rendering_queue.RenderingStates.RUNNING
-                    cont()
-                  }
 
-                  return
-                }
 
-                cont()
-              }
-            }
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.TextHighlighter = void 0;
 
-            const finishPaintTask = async (error = null) => {
-              if (paintTask === this.paintTask) {
-                this.paintTask = null
-              }
+class TextHighlighter {
+  constructor({
+    findController,
+    eventBus,
+    pageIndex
+  }) {
+    this.findController = findController;
+    this.matches = [];
+    this.eventBus = eventBus;
+    this.pageIdx = pageIndex;
+    this._onUpdateTextLayerMatches = null;
+    this.textDivs = null;
+    this.textContentItemsStr = null;
+    this.enabled = false;
+  }
 
-              if (error instanceof _pdfjsLib.RenderingCancelledException) {
-                this._renderError = null
-                return
-              }
+  setTextMapping(divs, texts) {
+    this.textDivs = divs;
+    this.textContentItemsStr = texts;
+  }
 
-              this._renderError = error
-              this.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED
+  enable() {
+    if (!this.textDivs || !this.textContentItemsStr) {
+      throw new Error("Text divs and strings have not been set.");
+    }
 
-              if (this.loadingIconDiv) {
-                div.removeChild(this.loadingIconDiv)
-                delete this.loadingIconDiv
-              }
+    if (this.enabled) {
+      throw new Error("TextHighlighter is already enabled.");
+    }
 
-              this._resetZoomLayer(true)
+    this.enabled = true;
 
-              this.eventBus.dispatch('pagerendered', {
-                source: this,
-                pageNumber: this.id,
-                cssTransform: false,
-                timestamp: performance.now(),
-                error: this._renderError
-              })
+    if (!this._onUpdateTextLayerMatches) {
+      this._onUpdateTextLayerMatches = evt => {
+        if (evt.pageIndex === this.pageIdx || evt.pageIndex === -1) {
+          this._updateMatches();
+        }
+      };
 
-              if (error) {
-                throw error
-              }
-            }
+      this.eventBus._on("updatetextlayermatches", this._onUpdateTextLayerMatches);
+    }
 
-            const paintTask = this.renderer === _ui_utils.RendererType.SVG ? this.paintOnSvg(canvasWrapper) : this.paintOnCanvas(canvasWrapper)
-            paintTask.onRenderContinue = renderContinueCallback
-            this.paintTask = paintTask
-            const resultPromise = paintTask.promise.then(function () {
-              return finishPaintTask(null).then(function () {
-                if (textLayer) {
-                  const readableStream = pdfPage.streamTextContent({
-                    normalizeWhitespace: true
-                  })
-                  textLayer.setTextContentStream(readableStream)
-                  textLayer.render()
-                }
-              })
-            }, function (reason) {
-              return finishPaintTask(reason)
-            })
-
-            if (this.annotationLayerFactory) {
-              if (!this.annotationLayer) {
-                this.annotationLayer = this.annotationLayerFactory.createAnnotationLayerBuilder(div, pdfPage, null, this.imageResourcesPath, this.renderInteractiveForms, this.l10n, this.enableScripting, null, null)
-              }
+    this._updateMatches();
+  }
 
-              this._renderAnnotationLayer()
-            }
+  disable() {
+    if (!this.enabled) {
+      return;
+    }
 
-            if (this.xfaLayerFactory) {
-              if (!this.xfaLayer) {
-                this.xfaLayer = this.xfaLayerFactory.createXfaLayerBuilder(div, pdfPage)
-              }
+    this.enabled = false;
 
-              this._renderXfaLayer()
-            }
+    if (this._onUpdateTextLayerMatches) {
+      this.eventBus._off("updatetextlayermatches", this._onUpdateTextLayerMatches);
 
-            div.setAttribute('data-loaded', true)
-            this.eventBus.dispatch('pagerender', {
-              source: this,
-              pageNumber: this.id
-            })
-            return resultPromise
-          }
+      this._onUpdateTextLayerMatches = null;
+    }
+  }
 
-          paintOnCanvas (canvasWrapper) {
-            const renderCapability = (0, _pdfjsLib.createPromiseCapability)()
-            const result = {
-              promise: renderCapability.promise,
+  _convertMatches(matches, matchesLength) {
+    if (!matches) {
+      return [];
+    }
 
-              onRenderContinue (cont) {
-                cont()
-              },
+    const {
+      textContentItemsStr
+    } = this;
+    let i = 0,
+        iIndex = 0;
+    const end = textContentItemsStr.length - 1;
+    const result = [];
 
-              cancel () {
-                renderTask.cancel()
-              }
+    for (let m = 0, mm = matches.length; m < mm; m++) {
+      let matchIdx = matches[m];
 
-            }
-            const viewport = this.viewport
-            const canvas = document.createElement('canvas')
-            canvas.hidden = true
-            let isCanvasHidden = true
-
-            const showCanvas = function () {
-              if (isCanvasHidden) {
-                canvas.hidden = false
-                isCanvasHidden = false
-              }
-            }
+      while (i !== end && matchIdx >= iIndex + textContentItemsStr[i].length) {
+        iIndex += textContentItemsStr[i].length;
+        i++;
+      }
 
-            canvasWrapper.appendChild(canvas)
-            this.canvas = canvas
-            canvas.mozOpaque = true
-            const ctx = canvas.getContext('2d', {
-              alpha: false,
-            })
-            const outputScale = (0, _ui_utils.getOutputScale)(ctx)
-            this.outputScale = outputScale
-
-            if (this.useOnlyCssZoom) {
-              const actualSizeViewport = viewport.clone({
-                scale: _ui_utils.CSS_UNITS
-              })
-              outputScale.sx *= actualSizeViewport.width / viewport.width
-              outputScale.sy *= actualSizeViewport.height / viewport.height
-              outputScale.scaled = true
-            }
+      if (i === textContentItemsStr.length) {
+        console.error("Could not find a matching mapping");
+      }
 
-            if (this.maxCanvasPixels > 0) {
-              const pixelsInViewport = viewport.width * viewport.height
-              const maxScale = Math.sqrt(this.maxCanvasPixels / pixelsInViewport)
-
-              if (outputScale.sx > maxScale || outputScale.sy > maxScale) {
-                outputScale.sx = maxScale
-                outputScale.sy = maxScale
-                outputScale.scaled = true
-                this.hasRestrictedScaling = true
-              } else {
-                this.hasRestrictedScaling = false
-              }
-            }
+      const match = {
+        begin: {
+          divIdx: i,
+          offset: matchIdx - iIndex
+        }
+      };
+      matchIdx += matchesLength[m];
 
-            const sfx = (0, _ui_utils.approximateFraction)(outputScale.sx)
-            const sfy = (0, _ui_utils.approximateFraction)(outputScale.sy)
-            canvas.width = (0, _ui_utils.roundToDivide)(viewport.width * outputScale.sx, sfx[0])
-            canvas.height = (0, _ui_utils.roundToDivide)(viewport.height * outputScale.sy, sfy[0])
-            canvas.style.width = (0, _ui_utils.roundToDivide)(viewport.width, sfx[1]) + 'px'
-            canvas.style.height = (0, _ui_utils.roundToDivide)(viewport.height, sfy[1]) + 'px'
-            this.paintedViewportMap.set(canvas, viewport)
-            const transform = !outputScale.scaled ? null : [outputScale.sx, 0, 0, outputScale.sy, 0, 0]
-            const renderContext = {
-              canvasContext: ctx,
-              transform,
-              viewport: this.viewport,
-              enableWebGL: this.enableWebGL,
-              renderInteractiveForms: this.renderInteractiveForms,
-              optionalContentConfigPromise: this._optionalContentConfigPromise,
-              // background: 'transparent',
-            }
-            const renderTask = this.pdfPage.render(renderContext)
+      while (i !== end && matchIdx > iIndex + textContentItemsStr[i].length) {
+        iIndex += textContentItemsStr[i].length;
+        i++;
+      }
 
-            renderTask.onContinue = function (cont) {
-              showCanvas()
+      match.end = {
+        divIdx: i,
+        offset: matchIdx - iIndex
+      };
+      result.push(match);
+    }
 
-              if (result.onRenderContinue) {
-                result.onRenderContinue(cont)
-              } else {
-                cont()
-              }
-            }
+    return result;
+  }
 
-            renderTask.promise.then(function () {
-              showCanvas()
-              renderCapability.resolve(undefined)
-            }, function (error) {
-              showCanvas()
-              renderCapability.reject(error)
-            })
-            return result
-          }
+  _renderMatches(matches) {
+    if (matches.length === 0) {
+      return;
+    }
 
-          paintOnSvg (wrapper) {
-            let cancelled = false
+    const {
+      findController,
+      pageIdx
+    } = this;
+    const {
+      textContentItemsStr,
+      textDivs
+    } = this;
+    const isSelectedPage = pageIdx === findController.selected.pageIdx;
+    const selectedMatchIdx = findController.selected.matchIdx;
+    const highlightAll = findController.state.highlightAll;
+    let prevEnd = null;
+    const infinity = {
+      divIdx: -1,
+      offset: undefined
+    };
+
+    function beginText(begin, className) {
+      const divIdx = begin.divIdx;
+      textDivs[divIdx].textContent = "";
+      return appendTextToDiv(divIdx, 0, begin.offset, className);
+    }
 
-            const ensureNotCancelled = () => {
-              if (cancelled) {
-                throw new _pdfjsLib.RenderingCancelledException(`Rendering cancelled, page ${this.id}`, 'svg')
-              }
-            }
+    function appendTextToDiv(divIdx, fromOffset, toOffset, className) {
+      let div = textDivs[divIdx];
 
-            const pdfPage = this.pdfPage
-            const actualSizeViewport = this.viewport.clone({
-              scale: _ui_utils.CSS_UNITS
-            })
-            const promise = pdfPage.getOperatorList().then(opList => {
-              ensureNotCancelled()
-              const svgGfx = new _pdfjsLib.SVGGraphics(pdfPage.commonObjs, pdfPage.objs, _viewer_compatibility.viewerCompatibilityParams.disableCreateObjectURL)
-              return svgGfx.getSVG(opList, actualSizeViewport).then(svg => {
-                ensureNotCancelled()
-                this.svg = svg
-                this.paintedViewportMap.set(svg, actualSizeViewport)
-                svg.style.width = wrapper.style.width
-                svg.style.height = wrapper.style.height
-                this.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED
-                wrapper.appendChild(svg)
-              })
-            })
-            return {
-              promise,
-
-              onRenderContinue (cont) {
-                cont()
-              },
-
-              cancel () {
-                cancelled = true
-              }
+      if (div.nodeType === Node.TEXT_NODE) {
+        const span = document.createElement("span");
+        div.parentNode.insertBefore(span, div);
+        span.appendChild(div);
+        textDivs[divIdx] = span;
+        div = span;
+      }
 
-            }
-          }
+      const content = textContentItemsStr[divIdx].substring(fromOffset, toOffset);
+      const node = document.createTextNode(content);
 
-          setPageLabel (label) {
-            this.pageLabel = typeof label === 'string' ? label : null
+      if (className) {
+        const span = document.createElement("span");
+        span.className = `${className} appended`;
+        span.appendChild(node);
+        div.appendChild(span);
+        return className.includes("selected") ? span.offsetLeft : 0;
+      }
 
-            if (this.pageLabel !== null) {
-              this.div.setAttribute('data-page-label', this.pageLabel)
-            } else {
-              this.div.removeAttribute('data-page-label')
-            }
-          }
+      div.appendChild(node);
+      return 0;
+    }
 
-        }
+    let i0 = selectedMatchIdx,
+        i1 = i0 + 1;
 
-        exports.PDFPageView = PDFPageView
+    if (highlightAll) {
+      i0 = 0;
+      i1 = matches.length;
+    } else if (!isSelectedPage) {
+      return;
+    }
 
-        /***/
-      }),
-      /* 15 */
-      /***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
-
-        Object.defineProperty(exports, '__esModule', ({
-          value: true
-        }))
-        exports.RenderingStates = exports.PDFRenderingQueue = void 0
-
-        var _pdfjsLib = __w_pdfjs_require__(2)
-
-        const CLEANUP_TIMEOUT = 30000
-        const RenderingStates = {
-          INITIAL: 0,
-          RUNNING: 1,
-          PAUSED: 2,
-          FINISHED: 3
+    for (let i = i0; i < i1; i++) {
+      const match = matches[i];
+      const begin = match.begin;
+      const end = match.end;
+      const isSelected = isSelectedPage && i === selectedMatchIdx;
+      const highlightSuffix = isSelected ? " selected" : "";
+      let selectedLeft = 0;
+
+      if (!prevEnd || begin.divIdx !== prevEnd.divIdx) {
+        if (prevEnd !== null) {
+          appendTextToDiv(prevEnd.divIdx, prevEnd.offset, infinity.offset);
         }
-        exports.RenderingStates = RenderingStates
-
-        class PDFRenderingQueue {
-          constructor () {
-            this.pdfViewer = null
-            this.pdfThumbnailViewer = null
-            this.onIdle = null
-            this.highestPriorityPage = null
-            this.idleTimeout = null
-            this.printing = false
-            this.isThumbnailViewEnabled = false
-          }
-
-          setViewer (pdfViewer) {
-            this.pdfViewer = pdfViewer
-          }
 
-          setThumbnailViewer (pdfThumbnailViewer) {
-            this.pdfThumbnailViewer = pdfThumbnailViewer
-          }
+        beginText(begin);
+      } else {
+        appendTextToDiv(prevEnd.divIdx, prevEnd.offset, begin.offset);
+      }
 
-          isHighestPriority (view) {
-            return this.highestPriorityPage === view.renderingId
-          }
+      if (begin.divIdx === end.divIdx) {
+        selectedLeft = appendTextToDiv(begin.divIdx, begin.offset, end.offset, "highlight" + highlightSuffix);
+      } else {
+        selectedLeft = appendTextToDiv(begin.divIdx, begin.offset, infinity.offset, "highlight begin" + highlightSuffix);
 
-          renderHighestPriority (currentlyVisiblePages) {
-            if (this.idleTimeout) {
-              clearTimeout(this.idleTimeout)
-              this.idleTimeout = null
-            }
+        for (let n0 = begin.divIdx + 1, n1 = end.divIdx; n0 < n1; n0++) {
+          textDivs[n0].className = "highlight middle" + highlightSuffix;
+        }
 
-            if (this.pdfViewer.forceRendering(currentlyVisiblePages)) {
-              return
-            }
+        beginText(end, "highlight end" + highlightSuffix);
+      }
 
-            if (this.pdfThumbnailViewer && this.isThumbnailViewEnabled) {
-              if (this.pdfThumbnailViewer.forceRendering()) {
-                return
-              }
-            }
+      prevEnd = end;
 
-            if (this.printing) {
-              return
-            }
+      if (isSelected) {
+        findController.scrollMatchIntoView({
+          element: textDivs[begin.divIdx],
+          selectedLeft,
+          pageIndex: pageIdx,
+          matchIndex: selectedMatchIdx
+        });
+      }
+    }
 
-            if (this.onIdle) {
-              this.idleTimeout = setTimeout(this.onIdle.bind(this), CLEANUP_TIMEOUT)
-            }
-          }
+    if (prevEnd) {
+      appendTextToDiv(prevEnd.divIdx, prevEnd.offset, infinity.offset);
+    }
+  }
 
-          getHighestPriority (visible, views, scrolledDown) {
-            const visibleViews = visible.views
-            const numVisible = visibleViews.length
+  _updateMatches() {
+    if (!this.enabled) {
+      return;
+    }
 
-            if (numVisible === 0) {
-              return null
-            }
+    const {
+      findController,
+      matches,
+      pageIdx
+    } = this;
+    const {
+      textContentItemsStr,
+      textDivs
+    } = this;
+    let clearedUntilDivIdx = -1;
+
+    for (let i = 0, ii = matches.length; i < ii; i++) {
+      const match = matches[i];
+      const begin = Math.max(clearedUntilDivIdx, match.begin.divIdx);
+
+      for (let n = begin, end = match.end.divIdx; n <= end; n++) {
+        const div = textDivs[n];
+        div.textContent = textContentItemsStr[n];
+        div.className = "";
+      }
 
-            for (let i = 0; i < numVisible; ++i) {
-              const view = visibleViews[i].view
+      clearedUntilDivIdx = match.end.divIdx + 1;
+    }
 
-              if (!this.isViewFinished(view)) {
-                return view
-              }
-            }
+    if (!findController?.highlightMatches) {
+      return;
+    }
 
-            if (scrolledDown) {
-              const nextPageIndex = visible.last.id
+    const pageMatches = findController.pageMatches[pageIdx] || null;
+    const pageMatchesLength = findController.pageMatchesLength[pageIdx] || null;
+    this.matches = this._convertMatches(pageMatches, pageMatchesLength);
 
-              if (views[nextPageIndex] && !this.isViewFinished(views[nextPageIndex])) {
-                return views[nextPageIndex]
-              }
-            } else {
-              const previousPageIndex = visible.first.id - 2
+    this._renderMatches(this.matches);
+  }
 
-              if (views[previousPageIndex] && !this.isViewFinished(views[previousPageIndex])) {
-                return views[previousPageIndex]
-              }
-            }
+}
 
-            return null
-          }
+exports.TextHighlighter = TextHighlighter;
 
-          isViewFinished (view) {
-            return view.renderingState === RenderingStates.FINISHED
-          }
+/***/ }),
+/* 16 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
 
-          renderView (view) {
-            switch (view.renderingState) {
-              case RenderingStates.FINISHED:
-                return false
-
-              case RenderingStates.PAUSED:
-                this.highestPriorityPage = view.renderingId
-                view.resume()
-                break
-
-              case RenderingStates.RUNNING:
-                this.highestPriorityPage = view.renderingId
-                break
-
-              case RenderingStates.INITIAL:
-                this.highestPriorityPage = view.renderingId
-                view.draw().finally(() => {
-                  this.renderHighestPriority()
-                }).catch(reason => {
-                  if (reason instanceof _pdfjsLib.RenderingCancelledException) {
-                    return
-                  }
-
-                  console.error(`renderView: "${reason}"`)
-                })
-                break
-            }
 
-            return true
-          }
 
-        }
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.DownloadManager = void 0;
 
-        exports.PDFRenderingQueue = PDFRenderingQueue
+var _pdfjsLib = __w_pdfjs_require__(3);
 
-        /***/
-      }),
-      /* 16 */
-      /***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
-
-        Object.defineProperty(exports, '__esModule', ({
-          value: true
-        }))
-        exports.PDFScriptingManager = void 0
-
-        var _pdfjsLib = __w_pdfjs_require__(2)
-
-        var _ui_utils = __w_pdfjs_require__(5)
-
-        var _pdf_rendering_queue = __w_pdfjs_require__(15)
-
-        class PDFScriptingManager {
-          constructor ({
-            eventBus,
-            sandboxBundleSrc = null,
-            scriptingFactory = null,
-            docPropertiesLookup = null
-          }) {
-            this._pdfDocument = null
-            this._pdfViewer = null
-            this._closeCapability = null
-            this._destroyCapability = null
-            this._scripting = null
-            this._mouseState = Object.create(null)
-            this._pageEventsReady = false
-            this._ready = false
-            this._eventBus = eventBus
-            this._sandboxBundleSrc = sandboxBundleSrc
-            this._scriptingFactory = scriptingFactory
-            this._docPropertiesLookup = docPropertiesLookup
-
-            if (!this._scriptingFactory) {
-              window.addEventListener('updatefromsandbox', event => {
-                this._eventBus.dispatch('updatefromsandbox', {
-                  source: window,
-                  detail: event.detail
-                })
-              })
-            }
-          }
+;
 
-          setViewer (pdfViewer) {
-            this._pdfViewer = pdfViewer
-          }
+function download(blobUrl, filename) {
+  const a = document.createElement("a");
 
-          async setDocument (pdfDocument) {
-            if (this._pdfDocument) {
-              await this._destroyScripting()
-            }
+  if (!a.click) {
+    throw new Error('DownloadManager: "a.click()" is not supported.');
+  }
 
-            this._pdfDocument = pdfDocument
+  a.href = blobUrl;
+  a.target = "_parent";
 
-            if (!pdfDocument) {
-              return
-            }
+  if ("download" in a) {
+    a.download = filename;
+  }
 
-            const [objects, calculationOrder, docActions] = await Promise.all([pdfDocument.getFieldObjects(), pdfDocument.getCalculationOrderIds(), pdfDocument.getJSActions()])
+  (document.body || document.documentElement).appendChild(a);
+  a.click();
+  a.remove();
+}
 
-            if (!objects && !docActions) {
-              await this._destroyScripting()
-              return
-            }
+class DownloadManager {
+  constructor() {
+    this._openBlobUrls = new WeakMap();
+  }
 
-            if (pdfDocument !== this._pdfDocument) {
-              return
-            }
+  downloadUrl(url, filename) {
+    if (!(0, _pdfjsLib.createValidAbsoluteUrl)(url, "http://example.com")) {
+      console.error(`downloadUrl - not a valid URL: ${url}`);
+      return;
+    }
 
-            this._scripting = this._createScripting()
+    download(url + "#pdfjs.action=download", filename);
+  }
 
-            this._internalEvents.set('updatefromsandbox', event => {
-              if (event?.source !== window) {
-                return
-              }
+  downloadData(data, filename, contentType) {
+    const blobUrl = URL.createObjectURL(new Blob([data], {
+      type: contentType
+    }));
+    download(blobUrl, filename);
+  }
 
-              this._updateFromSandbox(event.detail)
-            })
+  openOrDownloadData(element, data, filename) {
+    const isPdfData = (0, _pdfjsLib.isPdfFile)(filename);
+    const contentType = isPdfData ? "application/pdf" : "";
 
-            this._internalEvents.set('dispatcheventinsandbox', event => {
-              this._scripting?.dispatchEventInSandbox(event.detail)
-            })
+    if (isPdfData) {
+      let blobUrl = this._openBlobUrls.get(element);
 
-            this._internalEvents.set('pagechanging', ({
-              pageNumber,
-              previous
-            }) => {
-              if (pageNumber === previous) {
-                return
-              }
+      if (!blobUrl) {
+        blobUrl = URL.createObjectURL(new Blob([data], {
+          type: contentType
+        }));
 
-              this._dispatchPageClose(previous)
+        this._openBlobUrls.set(element, blobUrl);
+      }
 
-              this._dispatchPageOpen(pageNumber)
-            })
+      let viewerUrl;
+      viewerUrl = "?file=" + encodeURIComponent(blobUrl + "#" + filename);
 
-            this._internalEvents.set('pagerendered', ({
-              pageNumber
-            }) => {
-              if (!this._pageOpenPending.has(pageNumber)) {
-                return
-              }
+      try {
+        window.open(viewerUrl);
+        return true;
+      } catch (ex) {
+        console.error(`openOrDownloadData: ${ex}`);
+        URL.revokeObjectURL(blobUrl);
 
-              if (pageNumber !== this._pdfViewer.currentPageNumber) {
-                return
-              }
+        this._openBlobUrls.delete(element);
+      }
+    }
 
-              this._dispatchPageOpen(pageNumber)
-            })
+    this.downloadData(data, filename, contentType);
+    return false;
+  }
 
-            this._internalEvents.set('pagesdestroy', async event => {
-              await this._dispatchPageClose(this._pdfViewer.currentPageNumber)
-              await this._scripting?.dispatchEventInSandbox({
-                id: 'doc',
-                name: 'WillClose'
-              })
-              this._closeCapability?.resolve()
-            })
+  download(blob, url, filename, sourceEventType = "download") {
+    const blobUrl = URL.createObjectURL(blob);
+    download(blobUrl, filename);
+  }
 
-            this._domEvents.set('mousedown', event => {
-              this._mouseState.isDown = true
-            })
+}
 
-            this._domEvents.set('mouseup', event => {
-              this._mouseState.isDown = false
-            })
+exports.DownloadManager = DownloadManager;
 
-            for (const [name, listener] of this._internalEvents) {
-              this._eventBus._on(name, listener)
-            }
+/***/ }),
+/* 17 */
+/***/ ((__unused_webpack_module, exports) => {
 
-            for (const [name, listener] of this._domEvents) {
-              window.addEventListener(name, listener)
-            }
 
-            try {
-              const docProperties = await this._getDocProperties()
 
-              if (pdfDocument !== this._pdfDocument) {
-                return
-              }
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.WaitOnType = exports.EventBus = exports.AutomationEventBus = void 0;
+exports.waitOnEventOrTimeout = waitOnEventOrTimeout;
+const WaitOnType = {
+  EVENT: "event",
+  TIMEOUT: "timeout"
+};
+exports.WaitOnType = WaitOnType;
 
-              await this._scripting.createSandbox({
-                objects,
-                calculationOrder,
-                appInfo: {
-                  platform: navigator.platform,
-                  language: navigator.language
-                },
-                docInfo: {
-                  ...docProperties,
-                  actions: docActions
-                }
-              })
-
-              this._eventBus.dispatch('sandboxcreated', {
-                source: this
-              })
-            } catch (error) {
-              console.error(`PDFScriptingManager.setDocument: "${error?.message}".`)
-              await this._destroyScripting()
-              return
-            }
+function waitOnEventOrTimeout({
+  target,
+  name,
+  delay = 0
+}) {
+  return new Promise(function (resolve, reject) {
+    if (typeof target !== "object" || !(name && typeof name === "string") || !(Number.isInteger(delay) && delay >= 0)) {
+      throw new Error("waitOnEventOrTimeout - invalid parameters.");
+    }
 
-            await this._scripting?.dispatchEventInSandbox({
-              id: 'doc',
-              name: 'Open'
-            })
-            await this._dispatchPageOpen(this._pdfViewer.currentPageNumber, true)
-            Promise.resolve().then(() => {
-              if (pdfDocument === this._pdfDocument) {
-                this._ready = true
-              }
-            })
-          }
+    function handler(type) {
+      if (target instanceof EventBus) {
+        target._off(name, eventHandler);
+      } else {
+        target.removeEventListener(name, eventHandler);
+      }
 
-          async dispatchWillSave (detail) {
-            return this._scripting?.dispatchEventInSandbox({
-              id: 'doc',
-              name: 'WillSave'
-            })
-          }
+      if (timeout) {
+        clearTimeout(timeout);
+      }
 
-          async dispatchDidSave (detail) {
-            return this._scripting?.dispatchEventInSandbox({
-              id: 'doc',
-              name: 'DidSave'
-            })
-          }
+      resolve(type);
+    }
 
-          async dispatchWillPrint (detail) {
-            return this._scripting?.dispatchEventInSandbox({
-              id: 'doc',
-              name: 'WillPrint'
-            })
-          }
+    const eventHandler = handler.bind(null, WaitOnType.EVENT);
 
-          async dispatchDidPrint (detail) {
-            return this._scripting?.dispatchEventInSandbox({
-              id: 'doc',
-              name: 'DidPrint'
-            })
-          }
+    if (target instanceof EventBus) {
+      target._on(name, eventHandler);
+    } else {
+      target.addEventListener(name, eventHandler);
+    }
 
-          get mouseState () {
-            return this._mouseState
-          }
+    const timeoutHandler = handler.bind(null, WaitOnType.TIMEOUT);
+    const timeout = setTimeout(timeoutHandler, delay);
+  });
+}
+
+class EventBus {
+  constructor() {
+    this._listeners = Object.create(null);
+  }
+
+  on(eventName, listener, options = null) {
+    this._on(eventName, listener, {
+      external: true,
+      once: options?.once
+    });
+  }
+
+  off(eventName, listener, options = null) {
+    this._off(eventName, listener, {
+      external: true,
+      once: options?.once
+    });
+  }
+
+  dispatch(eventName, data) {
+    const eventListeners = this._listeners[eventName];
+
+    if (!eventListeners || eventListeners.length === 0) {
+      return;
+    }
 
-          get destroyPromise () {
-            return this._destroyCapability?.promise || null
-          }
+    let externalListeners;
 
-          get ready () {
-            return this._ready
-          }
+    for (const {
+      listener,
+      external,
+      once
+    } of eventListeners.slice(0)) {
+      if (once) {
+        this._off(eventName, listener);
+      }
 
-          get _internalEvents () {
-            return (0, _pdfjsLib.shadow)(this, '_internalEvents', new Map())
-          }
+      if (external) {
+        (externalListeners ||= []).push(listener);
+        continue;
+      }
 
-          get _domEvents () {
-            return (0, _pdfjsLib.shadow)(this, '_domEvents', new Map())
-          }
+      listener(data);
+    }
 
-          get _pageOpenPending () {
-            return (0, _pdfjsLib.shadow)(this, '_pageOpenPending', new Set())
-          }
+    if (externalListeners) {
+      for (const listener of externalListeners) {
+        listener(data);
+      }
 
-          get _visitedPages () {
-            return (0, _pdfjsLib.shadow)(this, '_visitedPages', new Map())
-          }
+      externalListeners = null;
+    }
+  }
+
+  _on(eventName, listener, options = null) {
+    const eventListeners = this._listeners[eventName] ||= [];
+    eventListeners.push({
+      listener,
+      external: options?.external === true,
+      once: options?.once === true
+    });
+  }
+
+  _off(eventName, listener, options = null) {
+    const eventListeners = this._listeners[eventName];
+
+    if (!eventListeners) {
+      return;
+    }
 
-          async _updateFromSandbox (detail) {
-            const isInPresentationMode = this._pdfViewer.isInPresentationMode || this._pdfViewer.isChangingPresentationMode
-            const {
-              id,
-              command,
-              value
-            } = detail
+    for (let i = 0, ii = eventListeners.length; i < ii; i++) {
+      if (eventListeners[i].listener === listener) {
+        eventListeners.splice(i, 1);
+        return;
+      }
+    }
+  }
 
-            if (!id) {
-              switch (command) {
-                case 'clear':
-                  console.clear()
-                  break
+}
 
-                case 'error':
-                  console.error(value)
-                  break
+exports.EventBus = EventBus;
 
-                case 'layout':
-                  this._pdfViewer.spreadMode = (0, _ui_utils.apiPageLayoutToSpreadMode)(value)
-                  break
+class AutomationEventBus extends EventBus {
+  dispatch(eventName, data) {
+    throw new Error("Not implemented: AutomationEventBus.dispatch");
+  }
 
-                case 'page-num':
-                  this._pdfViewer.currentPageNumber = value + 1
-                  break
+}
 
-                case 'print':
-                  await this._pdfViewer.pagesPromise
+exports.AutomationEventBus = AutomationEventBus;
 
-                  this._eventBus.dispatch('print', {
-                    source: this
-                  })
+/***/ }),
+/* 18 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
 
-                  break
 
-                case 'println':
-                  console.log(value)
-                  break
 
-                case 'zoom':
-                  if (isInPresentationMode) {
-                    return
-                  }
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.GenericL10n = void 0;
 
-                  this._pdfViewer.currentScaleValue = value
-                  break
-              }
+__w_pdfjs_require__(19);
 
-              return
-            }
+var _l10n_utils = __w_pdfjs_require__(4);
 
-            if (isInPresentationMode) {
-              if (detail.focus) {
-                return
-              }
-            }
+const webL10n = document.webL10n;
 
-            const element = document.getElementById(id)
+class GenericL10n {
+  constructor(lang) {
+    this._lang = lang;
+    this._ready = new Promise((resolve, reject) => {
+      webL10n.setLanguage((0, _l10n_utils.fixupLangCode)(lang), () => {
+        resolve(webL10n);
+      });
+    });
+  }
 
-            if (element) {
-              element.dispatchEvent(new CustomEvent('updatefromsandbox', {
-                detail
-              }))
-            } else {
-              delete detail.id
-              this._pdfDocument?.annotationStorage.setValue(id, detail)
-            }
-          }
+  async getLanguage() {
+    const l10n = await this._ready;
+    return l10n.getLanguage();
+  }
 
-          async _dispatchPageOpen (pageNumber, initialize = false) {
-            const pdfDocument = this._pdfDocument,
-              visitedPages = this._visitedPages
+  async getDirection() {
+    const l10n = await this._ready;
+    return l10n.getDirection();
+  }
 
-            if (initialize) {
-              this._closeCapability = (0, _pdfjsLib.createPromiseCapability)()
-              this._pageEventsReady = true
-            }
+  async get(key, args = null, fallback = (0, _l10n_utils.getL10nFallback)(key, args)) {
+    const l10n = await this._ready;
+    return l10n.get(key, args, fallback);
+  }
 
-            if (!this._pageEventsReady) {
-              return
-            }
+  async translate(element) {
+    const l10n = await this._ready;
+    return l10n.translate(element);
+  }
 
-            const pageView = this._pdfViewer.getPageView(pageNumber - 1)
+}
 
-            if (pageView?.renderingState !== _pdf_rendering_queue.RenderingStates.FINISHED) {
-              this._pageOpenPending.add(pageNumber)
+exports.GenericL10n = GenericL10n;
 
-              return
-            }
+/***/ }),
+/* 19 */
+/***/ (() => {
 
-            this._pageOpenPending.delete(pageNumber)
 
-            const actionsPromise = (async () => {
-              const actions = await (!visitedPages.has(pageNumber) ? pageView.pdfPage?.getJSActions() : null)
 
-              if (pdfDocument !== this._pdfDocument) {
-                return
-              }
+document.webL10n = function (window, document, undefined) {
+  var gL10nData = {};
+  var gTextData = '';
+  var gTextProp = 'textContent';
+  var gLanguage = '';
+  var gMacros = {};
+  var gReadyState = 'loading';
+  var gAsyncResourceLoading = true;
 
-              await this._scripting?.dispatchEventInSandbox({
-                id: 'page',
-                name: 'PageOpen',
-                pageNumber,
-                actions
-              })
-            })()
+  function getL10nResourceLinks() {
+    return document.querySelectorAll('link[type="application/l10n"]');
+  }
 
-            visitedPages.set(pageNumber, actionsPromise)
-          }
+  function getL10nDictionary() {
+    var script = document.querySelector('script[type="application/l10n"]');
+    return script ? JSON.parse(script.innerHTML) : null;
+  }
 
-          async _dispatchPageClose (pageNumber) {
-            const pdfDocument = this._pdfDocument,
-              visitedPages = this._visitedPages
+  function getTranslatableChildren(element) {
+    return element ? element.querySelectorAll('*[data-l10n-id]') : [];
+  }
 
-            if (!this._pageEventsReady) {
-              return
-            }
+  function getL10nAttributes(element) {
+    if (!element) return {};
+    var l10nId = element.getAttribute('data-l10n-id');
+    var l10nArgs = element.getAttribute('data-l10n-args');
+    var args = {};
 
-            if (this._pageOpenPending.has(pageNumber)) {
-              return
-            }
+    if (l10nArgs) {
+      try {
+        args = JSON.parse(l10nArgs);
+      } catch (e) {
+        console.warn('could not parse arguments for #' + l10nId);
+      }
+    }
 
-            const actionsPromise = visitedPages.get(pageNumber)
+    return {
+      id: l10nId,
+      args: args
+    };
+  }
 
-            if (!actionsPromise) {
-              return
-            }
+  function xhrLoadText(url, onSuccess, onFailure) {
+    onSuccess = onSuccess || function _onSuccess(data) {};
 
-            visitedPages.set(pageNumber, null)
-            await actionsPromise
+    onFailure = onFailure || function _onFailure() {};
 
-            if (pdfDocument !== this._pdfDocument) {
-              return
-            }
+    var xhr = new XMLHttpRequest();
+    xhr.open('GET', url, gAsyncResourceLoading);
 
-            await this._scripting?.dispatchEventInSandbox({
-              id: 'page',
-              name: 'PageClose',
-              pageNumber
-            })
-          }
+    if (xhr.overrideMimeType) {
+      xhr.overrideMimeType('text/plain; charset=utf-8');
+    }
 
-          async _getDocProperties () {
-            if (this._docPropertiesLookup) {
-              return this._docPropertiesLookup(this._pdfDocument)
-            }
+    xhr.onreadystatechange = function () {
+      if (xhr.readyState == 4) {
+        if (xhr.status == 200 || xhr.status === 0) {
+          onSuccess(xhr.responseText);
+        } else {
+          onFailure();
+        }
+      }
+    };
 
-            const {
-              docPropertiesLookup
-            } = __w_pdfjs_require__(17)
+    xhr.onerror = onFailure;
+    xhr.ontimeout = onFailure;
 
-            return docPropertiesLookup(this._pdfDocument)
-          }
+    try {
+      xhr.send(null);
+    } catch (e) {
+      onFailure();
+    }
+  }
 
-          _createScripting () {
-            this._destroyCapability = (0, _pdfjsLib.createPromiseCapability)()
+  function parseResource(href, lang, successCallback, failureCallback) {
+    var baseURL = href.replace(/[^\/]*$/, '') || './';
 
-            if (this._scripting) {
-              throw new Error('_createScripting: Scripting already exists.')
-            }
+    function evalString(text) {
+      if (text.lastIndexOf('\\') < 0) return text;
+      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, "'");
+    }
 
-            if (this._scriptingFactory) {
-              return this._scriptingFactory.createScripting({
-                sandboxBundleSrc: this._sandboxBundleSrc
-              })
+    function parseProperties(text, parsedPropertiesCallback) {
+      var dictionary = {};
+      var reBlank = /^\s*|\s*$/;
+      var reComment = /^\s*#|^\s*$/;
+      var reSection = /^\s*\[(.*)\]\s*$/;
+      var reImport = /^\s*@import\s+url\((.*)\)\s*$/i;
+      var reSplit = /^([^=\s]*)\s*=\s*(.+)$/;
+
+      function parseRawLines(rawText, extendedSyntax, parsedRawLinesCallback) {
+        var entries = rawText.replace(reBlank, '').split(/[\r\n]+/);
+        var currentLang = '*';
+        var genericLang = lang.split('-', 1)[0];
+        var skipLang = false;
+        var match = '';
+
+        function nextEntry() {
+          while (true) {
+            if (!entries.length) {
+              parsedRawLinesCallback();
+              return;
             }
 
-            const {
-              GenericScripting
-            } = __w_pdfjs_require__(17)
-
-            return new GenericScripting(this._sandboxBundleSrc)
-          }
-
-          async _destroyScripting () {
-            if (!this._scripting) {
-              this._pdfDocument = null
-              this._destroyCapability?.resolve()
-              return
-            }
+            var line = entries.shift();
+            if (reComment.test(line)) continue;
 
-            if (this._closeCapability) {
-              await Promise.race([this._closeCapability.promise, new Promise(resolve => {
-                setTimeout(resolve, 1000)
-              })]).catch(reason => {})
-              this._closeCapability = null
-            }
+            if (extendedSyntax) {
+              match = reSection.exec(line);
 
-            this._pdfDocument = null
+              if (match) {
+                currentLang = match[1].toLowerCase();
+                skipLang = currentLang !== '*' && currentLang !== lang && currentLang !== genericLang;
+                continue;
+              } else if (skipLang) {
+                continue;
+              }
 
-            try {
-              await this._scripting.destroySandbox()
-            } catch (ex) {}
+              match = reImport.exec(line);
 
-            for (const [name, listener] of this._internalEvents) {
-              this._eventBus._off(name, listener)
+              if (match) {
+                loadImport(baseURL + match[1], nextEntry);
+                return;
+              }
             }
 
-            this._internalEvents.clear()
+            var tmp = line.match(reSplit);
 
-            for (const [name, listener] of this._domEvents) {
-              window.removeEventListener(name, listener)
+            if (tmp && tmp.length == 3) {
+              dictionary[tmp[1]] = evalString(tmp[2]);
             }
+          }
+        }
 
-            this._domEvents.clear()
+        nextEntry();
+      }
 
-            this._pageOpenPending.clear()
+      function loadImport(url, callback) {
+        xhrLoadText(url, function (content) {
+          parseRawLines(content, false, callback);
+        }, function () {
+          console.warn(url + ' not found.');
+          callback();
+        });
+      }
 
-            this._visitedPages.clear()
+      parseRawLines(text, true, function () {
+        parsedPropertiesCallback(dictionary);
+      });
+    }
 
-            this._scripting = null
-            delete this._mouseState.isDown
-            this._pageEventsReady = false
-            this._ready = false
-            this._destroyCapability?.resolve()
+    xhrLoadText(href, function (response) {
+      gTextData += response;
+      parseProperties(response, function (data) {
+        for (var key in data) {
+          var id,
+              prop,
+              index = key.lastIndexOf('.');
+
+          if (index > 0) {
+            id = key.substring(0, index);
+            prop = key.substring(index + 1);
+          } else {
+            id = key;
+            prop = gTextProp;
           }
 
-        }
-
-        exports.PDFScriptingManager = PDFScriptingManager
-
-        /***/
-      }),
-      /* 17 */
-      /***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
-
-        Object.defineProperty(exports, '__esModule', ({
-          value: true
-        }))
-        exports.docPropertiesLookup = docPropertiesLookup
-        exports.GenericScripting = void 0
-
-        var _pdfjsLib = __w_pdfjs_require__(2)
-
-        async function docPropertiesLookup (pdfDocument) {
-          const url = '',
-            baseUrl = url.split('#')[0]
-          let {
-            info,
-            metadata,
-            contentDispositionFilename,
-            contentLength
-          } = await pdfDocument.getMetadata()
-
-          if (!contentLength) {
-            const {
-              length
-            } = await pdfDocument.getDownloadInfo()
-            contentLength = length
+          if (!gL10nData[id]) {
+            gL10nData[id] = {};
           }
 
-          return {
-            ...info,
-            baseURL: baseUrl,
-            filesize: contentLength,
-            filename: contentDispositionFilename || (0, _pdfjsLib.getPdfFilenameFromUrl)(url),
-            metadata: metadata?.getRaw(),
-            authors: metadata?.get('dc:creator'),
-            numPages: pdfDocument.numPages,
-            URL: url
-          }
+          gL10nData[id][prop] = data[key];
         }
 
-        class GenericScripting {
-          constructor (sandboxBundleSrc) {
-            this._ready = (0, _pdfjsLib.loadScript)(sandboxBundleSrc, true).then(() => {
-              return window.pdfjsSandbox.QuickJSSandbox()
-            })
-          }
+        if (successCallback) {
+          successCallback();
+        }
+      });
+    }, failureCallback);
+  }
 
-          async createSandbox (data) {
-            const sandbox = await this._ready
-            sandbox.create(data)
-          }
+  function loadLocale(lang, callback) {
+    if (lang) {
+      lang = lang.toLowerCase();
+    }
 
-          async dispatchEventInSandbox (event) {
-            const sandbox = await this._ready
-            sandbox.dispatchEvent(event)
-          }
+    callback = callback || function _callback() {};
 
-          async destroySandbox () {
-            const sandbox = await this._ready
-            sandbox.nukeSandbox()
-          }
+    clear();
+    gLanguage = lang;
+    var langLinks = getL10nResourceLinks();
+    var langCount = langLinks.length;
 
-        }
+    if (langCount === 0) {
+      var dict = getL10nDictionary();
 
-        exports.GenericScripting = GenericScripting
+      if (dict && dict.locales && dict.default_locale) {
+        console.log('using the embedded JSON directory, early way out');
+        gL10nData = dict.locales[lang];
 
-        /***/
-      }),
-      /* 18 */
-      /***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+        if (!gL10nData) {
+          var defaultLocale = dict.default_locale.toLowerCase();
 
-        Object.defineProperty(exports, '__esModule', ({
-          value: true
-        }))
-        exports.PDFSinglePageViewer = void 0
+          for (var anyCaseLang in dict.locales) {
+            anyCaseLang = anyCaseLang.toLowerCase();
 
-        var _base_viewer = __w_pdfjs_require__(19)
+            if (anyCaseLang === lang) {
+              gL10nData = dict.locales[lang];
+              break;
+            } else if (anyCaseLang === defaultLocale) {
+              gL10nData = dict.locales[defaultLocale];
+            }
+          }
+        }
 
-        var _pdfjsLib = __w_pdfjs_require__(2)
+        callback();
+      } else {
+        console.log('no resource to load, early way out');
+      }
 
-        class PDFSinglePageViewer extends _base_viewer.BaseViewer {
-          constructor (options) {
-            super(options)
+      gReadyState = 'complete';
+      return;
+    }
 
-            this.eventBus._on('pagesinit', evt => {
-              this._ensurePageViewVisible()
-            })
-          }
+    var onResourceLoaded = null;
+    var gResourceCount = 0;
 
-          get _viewerElement () {
-            return (0, _pdfjsLib.shadow)(this, '_viewerElement', this._shadowViewer)
-          }
+    onResourceLoaded = function () {
+      gResourceCount++;
 
-          get _pageWidthScaleFactor () {
-            return 1
-          }
+      if (gResourceCount >= langCount) {
+        callback();
+        gReadyState = 'complete';
+      }
+    };
+
+    function L10nResourceLink(link) {
+      var href = link.href;
+
+      this.load = function (lang, callback) {
+        parseResource(href, lang, callback, function () {
+          console.warn(href + ' not found.');
+          console.warn('"' + lang + '" resource not found');
+          gLanguage = '';
+          callback();
+        });
+      };
+    }
 
-          _resetView () {
-            super._resetView()
+    for (var i = 0; i < langCount; i++) {
+      var resource = new L10nResourceLink(langLinks[i]);
+      resource.load(lang, onResourceLoaded);
+    }
+  }
+
+  function clear() {
+    gL10nData = {};
+    gTextData = '';
+    gLanguage = '';
+  }
+
+  function getPluralRules(lang) {
+    var locales2rules = {
+      'af': 3,
+      'ak': 4,
+      'am': 4,
+      'ar': 1,
+      'asa': 3,
+      'az': 0,
+      'be': 11,
+      'bem': 3,
+      'bez': 3,
+      'bg': 3,
+      'bh': 4,
+      'bm': 0,
+      'bn': 3,
+      'bo': 0,
+      'br': 20,
+      'brx': 3,
+      'bs': 11,
+      'ca': 3,
+      'cgg': 3,
+      'chr': 3,
+      'cs': 12,
+      'cy': 17,
+      'da': 3,
+      'de': 3,
+      'dv': 3,
+      'dz': 0,
+      'ee': 3,
+      'el': 3,
+      'en': 3,
+      'eo': 3,
+      'es': 3,
+      'et': 3,
+      'eu': 3,
+      'fa': 0,
+      'ff': 5,
+      'fi': 3,
+      'fil': 4,
+      'fo': 3,
+      'fr': 5,
+      'fur': 3,
+      'fy': 3,
+      'ga': 8,
+      'gd': 24,
+      'gl': 3,
+      'gsw': 3,
+      'gu': 3,
+      'guw': 4,
+      'gv': 23,
+      'ha': 3,
+      'haw': 3,
+      'he': 2,
+      'hi': 4,
+      'hr': 11,
+      'hu': 0,
+      'id': 0,
+      'ig': 0,
+      'ii': 0,
+      'is': 3,
+      'it': 3,
+      'iu': 7,
+      'ja': 0,
+      'jmc': 3,
+      'jv': 0,
+      'ka': 0,
+      'kab': 5,
+      'kaj': 3,
+      'kcg': 3,
+      'kde': 0,
+      'kea': 0,
+      'kk': 3,
+      'kl': 3,
+      'km': 0,
+      'kn': 0,
+      'ko': 0,
+      'ksb': 3,
+      'ksh': 21,
+      'ku': 3,
+      'kw': 7,
+      'lag': 18,
+      'lb': 3,
+      'lg': 3,
+      'ln': 4,
+      'lo': 0,
+      'lt': 10,
+      'lv': 6,
+      'mas': 3,
+      'mg': 4,
+      'mk': 16,
+      'ml': 3,
+      'mn': 3,
+      'mo': 9,
+      'mr': 3,
+      'ms': 0,
+      'mt': 15,
+      'my': 0,
+      'nah': 3,
+      'naq': 7,
+      'nb': 3,
+      'nd': 3,
+      'ne': 3,
+      'nl': 3,
+      'nn': 3,
+      'no': 3,
+      'nr': 3,
+      'nso': 4,
+      'ny': 3,
+      'nyn': 3,
+      'om': 3,
+      'or': 3,
+      'pa': 3,
+      'pap': 3,
+      'pl': 13,
+      'ps': 3,
+      'pt': 3,
+      'rm': 3,
+      'ro': 9,
+      'rof': 3,
+      'ru': 11,
+      'rwk': 3,
+      'sah': 0,
+      'saq': 3,
+      'se': 7,
+      'seh': 3,
+      'ses': 0,
+      'sg': 0,
+      'sh': 11,
+      'shi': 19,
+      'sk': 12,
+      'sl': 14,
+      'sma': 7,
+      'smi': 7,
+      'smj': 7,
+      'smn': 7,
+      'sms': 7,
+      'sn': 3,
+      'so': 3,
+      'sq': 3,
+      'sr': 11,
+      'ss': 3,
+      'ssy': 3,
+      'st': 3,
+      'sv': 3,
+      'sw': 3,
+      'syr': 3,
+      'ta': 3,
+      'te': 3,
+      'teo': 3,
+      'th': 0,
+      'ti': 4,
+      'tig': 3,
+      'tk': 3,
+      'tl': 4,
+      'tn': 3,
+      'to': 0,
+      'tr': 0,
+      'ts': 3,
+      'tzm': 22,
+      'uk': 11,
+      'ur': 3,
+      've': 3,
+      'vi': 0,
+      'vun': 3,
+      'wa': 4,
+      'wae': 3,
+      'wo': 0,
+      'xh': 3,
+      'xog': 3,
+      'yo': 0,
+      'zh': 0,
+      'zu': 3
+    };
+
+    function isIn(n, list) {
+      return list.indexOf(n) !== -1;
+    }
 
-            this._previousPageNumber = 1
-            this._shadowViewer = document.createDocumentFragment()
-            this._updateScrollDown = null
-          }
+    function isBetween(n, start, end) {
+      return start <= n && n <= end;
+    }
 
-          _ensurePageViewVisible () {
-            const pageView = this._pages[this._currentPageNumber - 1]
-            const previousPageView = this._pages[this._previousPageNumber - 1]
-            const viewerNodes = this.viewer.childNodes
+    var pluralRules = {
+      '0': function (n) {
+        return 'other';
+      },
+      '1': function (n) {
+        if (isBetween(n % 100, 3, 10)) return 'few';
+        if (n === 0) return 'zero';
+        if (isBetween(n % 100, 11, 99)) return 'many';
+        if (n == 2) return 'two';
+        if (n == 1) return 'one';
+        return 'other';
+      },
+      '2': function (n) {
+        if (n !== 0 && n % 10 === 0) return 'many';
+        if (n == 2) return 'two';
+        if (n == 1) return 'one';
+        return 'other';
+      },
+      '3': function (n) {
+        if (n == 1) return 'one';
+        return 'other';
+      },
+      '4': function (n) {
+        if (isBetween(n, 0, 1)) return 'one';
+        return 'other';
+      },
+      '5': function (n) {
+        if (isBetween(n, 0, 2) && n != 2) return 'one';
+        return 'other';
+      },
+      '6': function (n) {
+        if (n === 0) return 'zero';
+        if (n % 10 == 1 && n % 100 != 11) return 'one';
+        return 'other';
+      },
+      '7': function (n) {
+        if (n == 2) return 'two';
+        if (n == 1) return 'one';
+        return 'other';
+      },
+      '8': function (n) {
+        if (isBetween(n, 3, 6)) return 'few';
+        if (isBetween(n, 7, 10)) return 'many';
+        if (n == 2) return 'two';
+        if (n == 1) return 'one';
+        return 'other';
+      },
+      '9': function (n) {
+        if (n === 0 || n != 1 && isBetween(n % 100, 1, 19)) return 'few';
+        if (n == 1) return 'one';
+        return 'other';
+      },
+      '10': function (n) {
+        if (isBetween(n % 10, 2, 9) && !isBetween(n % 100, 11, 19)) return 'few';
+        if (n % 10 == 1 && !isBetween(n % 100, 11, 19)) return 'one';
+        return 'other';
+      },
+      '11': function (n) {
+        if (isBetween(n % 10, 2, 4) && !isBetween(n % 100, 12, 14)) return 'few';
+        if (n % 10 === 0 || isBetween(n % 10, 5, 9) || isBetween(n % 100, 11, 14)) return 'many';
+        if (n % 10 == 1 && n % 100 != 11) return 'one';
+        return 'other';
+      },
+      '12': function (n) {
+        if (isBetween(n, 2, 4)) return 'few';
+        if (n == 1) return 'one';
+        return 'other';
+      },
+      '13': function (n) {
+        if (isBetween(n % 10, 2, 4) && !isBetween(n % 100, 12, 14)) return 'few';
+        if (n != 1 && isBetween(n % 10, 0, 1) || isBetween(n % 10, 5, 9) || isBetween(n % 100, 12, 14)) return 'many';
+        if (n == 1) return 'one';
+        return 'other';
+      },
+      '14': function (n) {
+        if (isBetween(n % 100, 3, 4)) return 'few';
+        if (n % 100 == 2) return 'two';
+        if (n % 100 == 1) return 'one';
+        return 'other';
+      },
+      '15': function (n) {
+        if (n === 0 || isBetween(n % 100, 2, 10)) return 'few';
+        if (isBetween(n % 100, 11, 19)) return 'many';
+        if (n == 1) return 'one';
+        return 'other';
+      },
+      '16': function (n) {
+        if (n % 10 == 1 && n != 11) return 'one';
+        return 'other';
+      },
+      '17': function (n) {
+        if (n == 3) return 'few';
+        if (n === 0) return 'zero';
+        if (n == 6) return 'many';
+        if (n == 2) return 'two';
+        if (n == 1) return 'one';
+        return 'other';
+      },
+      '18': function (n) {
+        if (n === 0) return 'zero';
+        if (isBetween(n, 0, 2) && n !== 0 && n != 2) return 'one';
+        return 'other';
+      },
+      '19': function (n) {
+        if (isBetween(n, 2, 10)) return 'few';
+        if (isBetween(n, 0, 1)) return 'one';
+        return 'other';
+      },
+      '20': function (n) {
+        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';
+        if (n % 1000000 === 0 && n !== 0) return 'many';
+        if (n % 10 == 2 && !isIn(n % 100, [12, 72, 92])) return 'two';
+        if (n % 10 == 1 && !isIn(n % 100, [11, 71, 91])) return 'one';
+        return 'other';
+      },
+      '21': function (n) {
+        if (n === 0) return 'zero';
+        if (n == 1) return 'one';
+        return 'other';
+      },
+      '22': function (n) {
+        if (isBetween(n, 0, 1) || isBetween(n, 11, 99)) return 'one';
+        return 'other';
+      },
+      '23': function (n) {
+        if (isBetween(n % 10, 1, 2) || n % 20 === 0) return 'one';
+        return 'other';
+      },
+      '24': function (n) {
+        if (isBetween(n, 3, 10) || isBetween(n, 13, 19)) return 'few';
+        if (isIn(n, [2, 12])) return 'two';
+        if (isIn(n, [1, 11])) return 'one';
+        return 'other';
+      }
+    };
+    var index = locales2rules[lang.replace(/-.*$/, '')];
+
+    if (!(index in pluralRules)) {
+      console.warn('plural form unknown for [' + lang + ']');
+      return function () {
+        return 'other';
+      };
+    }
 
-            switch (viewerNodes.length) {
-              case 0:
-                this.viewer.appendChild(pageView.div)
-                break
+    return pluralRules[index];
+  }
 
-              case 1:
-                if (viewerNodes[0] !== previousPageView.div) {
-                  throw new Error('_ensurePageViewVisible: Unexpected previously visible page.')
-                }
+  gMacros.plural = function (str, param, key, prop) {
+    var n = parseFloat(param);
+    if (isNaN(n)) return str;
+    if (prop != gTextProp) return str;
 
-                if (pageView === previousPageView) {
-                  break
-                }
+    if (!gMacros._pluralRules) {
+      gMacros._pluralRules = getPluralRules(gLanguage);
+    }
 
-                this._shadowViewer.appendChild(previousPageView.div)
+    var index = '[' + gMacros._pluralRules(n) + ']';
+
+    if (n === 0 && key + '[zero]' in gL10nData) {
+      str = gL10nData[key + '[zero]'][prop];
+    } else if (n == 1 && key + '[one]' in gL10nData) {
+      str = gL10nData[key + '[one]'][prop];
+    } else if (n == 2 && key + '[two]' in gL10nData) {
+      str = gL10nData[key + '[two]'][prop];
+    } else if (key + index in gL10nData) {
+      str = gL10nData[key + index][prop];
+    } else if (key + '[other]' in gL10nData) {
+      str = gL10nData[key + '[other]'][prop];
+    }
 
-                this.viewer.appendChild(pageView.div)
-                this.container.scrollTop = 0
-                break
+    return str;
+  };
 
-              default:
-                throw new Error('_ensurePageViewVisible: Only one page should be visible at a time.')
-            }
+  function getL10nData(key, args, fallback) {
+    var data = gL10nData[key];
 
-            this._previousPageNumber = this._currentPageNumber
-          }
+    if (!data) {
+      console.warn('#' + key + ' is undefined.');
 
-          _scrollUpdate () {
-            if (this._updateScrollDown) {
-              this._updateScrollDown()
-            }
+      if (!fallback) {
+        return null;
+      }
 
-            super._scrollUpdate()
-          }
+      data = fallback;
+    }
 
-          _scrollIntoView ({
-            pageDiv,
-            pageSpot = null,
-            pageNumber = null
-          }) {
-            if (pageNumber) {
-              this._setCurrentPageNumber(pageNumber)
-            }
+    var rv = {};
 
-            const scrolledDown = this._currentPageNumber >= this._previousPageNumber
+    for (var prop in data) {
+      var str = data[prop];
+      str = substIndexes(str, args, key, prop);
+      str = substArguments(str, args, key);
+      rv[prop] = str;
+    }
 
-            this._ensurePageViewVisible()
+    return rv;
+  }
+
+  function substIndexes(str, args, key, prop) {
+    var reIndex = /\{\[\s*([a-zA-Z]+)\(([a-zA-Z]+)\)\s*\]\}/;
+    var reMatch = reIndex.exec(str);
+    if (!reMatch || !reMatch.length) return str;
+    var macroName = reMatch[1];
+    var paramName = reMatch[2];
+    var param;
+
+    if (args && paramName in args) {
+      param = args[paramName];
+    } else if (paramName in gL10nData) {
+      param = gL10nData[paramName];
+    }
 
-            this.update()
+    if (macroName in gMacros) {
+      var macro = gMacros[macroName];
+      str = macro(str, param, key, prop);
+    }
 
-            super._scrollIntoView({
-              pageDiv,
-              pageSpot,
-              pageNumber
-            })
+    return str;
+  }
 
-            this._updateScrollDown = () => {
-              this.scroll.down = scrolledDown
-              this._updateScrollDown = null
-            }
-          }
+  function substArguments(str, args, key) {
+    var reArgs = /\{\{\s*(.+?)\s*\}\}/g;
+    return str.replace(reArgs, function (matched_text, arg) {
+      if (args && arg in args) {
+        return args[arg];
+      }
 
-          _getVisiblePages () {
-            return this._getCurrentVisiblePage()
-          }
+      if (arg in gL10nData) {
+        return gL10nData[arg];
+      }
 
-          _updateHelper (visiblePages) {}
+      console.log('argument {{' + arg + '}} for #' + key + ' is undefined.');
+      return matched_text;
+    });
+  }
 
-          get _isScrollModeHorizontal () {
-            return (0, _pdfjsLib.shadow)(this, '_isScrollModeHorizontal', false)
-          }
+  function translateElement(element) {
+    var l10n = getL10nAttributes(element);
+    if (!l10n.id) return;
+    var data = getL10nData(l10n.id, l10n.args);
 
-          _updateScrollMode () {}
+    if (!data) {
+      console.warn('#' + l10n.id + ' is undefined.');
+      return;
+    }
 
-          _updateSpreadMode () {}
+    if (data[gTextProp]) {
+      if (getChildElementCount(element) === 0) {
+        element[gTextProp] = data[gTextProp];
+      } else {
+        var children = element.childNodes;
+        var found = false;
 
-          _getPageAdvance () {
-            return 1
+        for (var i = 0, l = children.length; i < l; i++) {
+          if (children[i].nodeType === 3 && /\S/.test(children[i].nodeValue)) {
+            if (found) {
+              children[i].nodeValue = '';
+            } else {
+              children[i].nodeValue = data[gTextProp];
+              found = true;
+            }
           }
+        }
 
+        if (!found) {
+          var textNode = document.createTextNode(data[gTextProp]);
+          element.insertBefore(textNode, element.firstChild);
         }
+      }
 
-        exports.PDFSinglePageViewer = PDFSinglePageViewer
+      delete data[gTextProp];
+    }
 
-        /***/
-      }),
-      /* 19 */
-      /***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+    for (var k in data) {
+      element[k] = data[k];
+    }
+  }
 
-        Object.defineProperty(exports, '__esModule', ({
-          value: true
-        }))
-        exports.BaseViewer = void 0
+  function getChildElementCount(element) {
+    if (element.children) {
+      return element.children.length;
+    }
 
-        var _pdfjsLib = __w_pdfjs_require__(2)
+    if (typeof element.childElementCount !== 'undefined') {
+      return element.childElementCount;
+    }
 
-        var _ui_utils = __w_pdfjs_require__(5)
+    var count = 0;
 
-        var _pdf_rendering_queue = __w_pdfjs_require__(15)
+    for (var i = 0; i < element.childNodes.length; i++) {
+      count += element.nodeType === 1 ? 1 : 0;
+    }
 
-        var _annotation_layer_builder = __w_pdfjs_require__(1)
+    return count;
+  }
 
-        var _l10n_utils = __w_pdfjs_require__(3)
+  function translateFragment(element) {
+    element = element || document.documentElement;
+    var children = getTranslatableChildren(element);
+    var elementCount = children.length;
 
-        var _pdf_page_view = __w_pdfjs_require__(14)
+    for (var i = 0; i < elementCount; i++) {
+      translateElement(children[i]);
+    }
 
-        var _pdf_link_service = __w_pdfjs_require__(4)
+    translateElement(element);
+  }
 
-        var _text_layer_builder = __w_pdfjs_require__(6)
+  return {
+    get: function (key, args, fallbackString) {
+      var index = key.lastIndexOf('.');
+      var prop = gTextProp;
 
-        var _xfa_layer_builder = __w_pdfjs_require__(20)
+      if (index > 0) {
+        prop = key.substring(index + 1);
+        key = key.substring(0, index);
+      }
 
-        const DEFAULT_CACHE_SIZE = 10
+      var fallback;
 
-        function PDFPageViewBuffer (size) {
-          const data = []
+      if (fallbackString) {
+        fallback = {};
+        fallback[prop] = fallbackString;
+      }
 
-          this.push = function (view) {
-            const i = data.indexOf(view)
+      var data = getL10nData(key, args, fallback);
 
-            if (i >= 0) {
-              data.splice(i, 1)
-            }
+      if (data && prop in data) {
+        return data[prop];
+      }
 
-            data.push(view)
+      return '{{' + key + '}}';
+    },
+    getData: function () {
+      return gL10nData;
+    },
+    getText: function () {
+      return gTextData;
+    },
+    getLanguage: function () {
+      return gLanguage;
+    },
+    setLanguage: function (lang, callback) {
+      loadLocale(lang, function () {
+        if (callback) callback();
+      });
+    },
+    getDirection: function () {
+      var rtlList = ['ar', 'he', 'fa', 'ps', 'ur'];
+      var shortCode = gLanguage.split('-', 1)[0];
+      return rtlList.indexOf(shortCode) >= 0 ? 'rtl' : 'ltr';
+    },
+    translate: translateFragment,
+    getReadyState: function () {
+      return gReadyState;
+    },
+    ready: function (callback) {
+      if (!callback) {
+        return;
+      } else if (gReadyState == 'complete' || gReadyState == 'interactive') {
+        window.setTimeout(function () {
+          callback();
+        });
+      } else if (document.addEventListener) {
+        document.addEventListener('localized', function once() {
+          document.removeEventListener('localized', once);
+          callback();
+        });
+      }
+    }
+  };
+}(window, document);
+
+/***/ }),
+/* 20 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDFFindController = exports.FindState = void 0;
+
+var _ui_utils = __w_pdfjs_require__(6);
+
+var _pdfjsLib = __w_pdfjs_require__(3);
+
+var _pdf_find_utils = __w_pdfjs_require__(21);
+
+const FindState = {
+  FOUND: 0,
+  NOT_FOUND: 1,
+  WRAPPED: 2,
+  PENDING: 3
+};
+exports.FindState = FindState;
+const FIND_TIMEOUT = 250;
+const MATCH_SCROLL_OFFSET_TOP = -50;
+const MATCH_SCROLL_OFFSET_LEFT = -400;
+const CHARACTERS_TO_NORMALIZE = {
+  "\u2010": "-",
+  "\u2018": "'",
+  "\u2019": "'",
+  "\u201A": "'",
+  "\u201B": "'",
+  "\u201C": '"',
+  "\u201D": '"',
+  "\u201E": '"',
+  "\u201F": '"',
+  "\u00BC": "1/4",
+  "\u00BD": "1/2",
+  "\u00BE": "3/4"
+};
+const DIACRITICS_EXCEPTION = new Set([0x3099, 0x309a, 0x094d, 0x09cd, 0x0a4d, 0x0acd, 0x0b4d, 0x0bcd, 0x0c4d, 0x0ccd, 0x0d3b, 0x0d3c, 0x0d4d, 0x0dca, 0x0e3a, 0x0eba, 0x0f84, 0x1039, 0x103a, 0x1714, 0x1734, 0x17d2, 0x1a60, 0x1b44, 0x1baa, 0x1bab, 0x1bf2, 0x1bf3, 0x2d7f, 0xa806, 0xa82c, 0xa8c4, 0xa953, 0xa9c0, 0xaaf6, 0xabed, 0x0c56, 0x0f71, 0x0f72, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f80, 0x0f74]);
+const DIACRITICS_EXCEPTION_STR = [...DIACRITICS_EXCEPTION.values()].map(x => String.fromCharCode(x)).join("");
+const DIACRITICS_REG_EXP = /\p{M}+/gu;
+const SPECIAL_CHARS_REG_EXP = /([.*+?^${}()|[\]\\])|(\p{P})|(\s+)|(\p{M})|(\p{L})/gu;
+const NOT_DIACRITIC_FROM_END_REG_EXP = /([^\p{M}])\p{M}*$/u;
+const NOT_DIACRITIC_FROM_START_REG_EXP = /^\p{M}*([^\p{M}])/u;
+let normalizationRegex = null;
+
+function normalize(text) {
+  if (!normalizationRegex) {
+    const replace = Object.keys(CHARACTERS_TO_NORMALIZE).join("");
+    normalizationRegex = new RegExp(`([${replace}])|(\\p{M}+(?:-\\n)?)|(\\S-\\n)|(\\n)`, "gum");
+  }
+
+  const rawDiacriticsPositions = [];
+  let m;
+
+  while ((m = DIACRITICS_REG_EXP.exec(text)) !== null) {
+    rawDiacriticsPositions.push([m[0].length, m.index]);
+  }
+
+  let normalized = text.normalize("NFD");
+  const positions = [[0, 0]];
+  let k = 0;
+  let shift = 0;
+  let shiftOrigin = 0;
+  let eol = 0;
+  let hasDiacritics = false;
+  normalized = normalized.replace(normalizationRegex, (match, p1, p2, p3, p4, i) => {
+    i -= shiftOrigin;
+
+    if (p1) {
+      const replacement = CHARACTERS_TO_NORMALIZE[match];
+      const jj = replacement.length;
+
+      for (let j = 1; j < jj; j++) {
+        positions.push([i - shift + j, shift - j]);
+      }
 
-            if (data.length > size) {
-              data.shift().destroy()
-            }
-          }
+      shift -= jj - 1;
+      return replacement;
+    }
 
-          this.resize = function (newSize, pagesToKeep) {
-            size = newSize
+    if (p2) {
+      const hasTrailingDashEOL = p2.endsWith("\n");
+      const len = hasTrailingDashEOL ? p2.length - 2 : p2.length;
+      hasDiacritics = true;
+      let jj = len;
 
-            if (pagesToKeep) {
-              const pageIdsToKeep = new Set()
+      if (i + eol === rawDiacriticsPositions[k]?.[1]) {
+        jj -= rawDiacriticsPositions[k][0];
+        ++k;
+      }
 
-              for (let i = 0, iMax = pagesToKeep.length; i < iMax; ++i) {
-                pageIdsToKeep.add(pagesToKeep[i].id)
-              }
+      for (let j = 1; j < jj + 1; j++) {
+        positions.push([i - 1 - shift + j, shift - j]);
+      }
 
-              (0, _ui_utils.moveToEndOfArray)(data, function (page) {
-                return pageIdsToKeep.has(page.id)
-              })
-            }
+      shift -= jj;
+      shiftOrigin += jj;
 
-            while (data.length > size) {
-              data.shift().destroy()
-            }
-          }
+      if (hasTrailingDashEOL) {
+        i += len - 1;
+        positions.push([i - shift + 1, 1 + shift]);
+        shift += 1;
+        shiftOrigin += 1;
+        eol += 1;
+        return p2.slice(0, len);
+      }
 
-          this.has = function (view) {
-            return data.includes(view)
-          }
-        }
+      return p2;
+    }
 
-        function isSameScale (oldScale, newScale) {
-          if (newScale === oldScale) {
-            return true
-          }
+    if (p3) {
+      positions.push([i - shift + 1, 1 + shift]);
+      shift += 1;
+      shiftOrigin += 1;
+      eol += 1;
+      return p3.charAt(0);
+    }
 
-          if (Math.abs(newScale - oldScale) < 1e-15) {
-            return true
-          }
+    positions.push([i - shift + 1, shift - 1]);
+    shift -= 1;
+    shiftOrigin += 1;
+    eol += 1;
+    return " ";
+  });
+  positions.push([normalized.length, shift]);
+  return [normalized, positions, hasDiacritics];
+}
+
+function getOriginalIndex(diffs, pos, len) {
+  if (!diffs) {
+    return [pos, len];
+  }
+
+  const start = pos;
+  const end = pos + len;
+  let i = (0, _ui_utils.binarySearchFirstItem)(diffs, x => x[0] >= start);
+
+  if (diffs[i][0] > start) {
+    --i;
+  }
+
+  let j = (0, _ui_utils.binarySearchFirstItem)(diffs, x => x[0] >= end, i);
+
+  if (diffs[j][0] > end) {
+    --j;
+  }
+
+  return [start + diffs[i][1], len + diffs[j][1] - diffs[i][1]];
+}
+
+class PDFFindController {
+  constructor({
+    linkService,
+    eventBus
+  }) {
+    this._linkService = linkService;
+    this._eventBus = eventBus;
+    this.#reset();
+
+    eventBus._on("find", this.#onFind.bind(this));
+
+    eventBus._on("findbarclose", this.#onFindBarClose.bind(this));
+  }
+
+  get highlightMatches() {
+    return this._highlightMatches;
+  }
+
+  get pageMatches() {
+    return this._pageMatches;
+  }
+
+  get pageMatchesLength() {
+    return this._pageMatchesLength;
+  }
+
+  get selected() {
+    return this._selected;
+  }
+
+  get state() {
+    return this._state;
+  }
+
+  setDocument(pdfDocument) {
+    if (this._pdfDocument) {
+      this.#reset();
+    }
 
-          return false
-        }
+    if (!pdfDocument) {
+      return;
+    }
 
-        class BaseViewer {
-          constructor (options) {
-            if (this.constructor === BaseViewer) {
-              throw new Error('Cannot initialize BaseViewer.')
-            }
+    this._pdfDocument = pdfDocument;
 
-            const viewerVersion = '2.8.335'
+    this._firstPageCapability.resolve();
+  }
 
-            if (_pdfjsLib.version !== viewerVersion) {
-              throw new Error(`The API version "${_pdfjsLib.version}" does not match the Viewer version "${viewerVersion}".`)
-            }
+  #onFind(state) {
+    if (!state) {
+      return;
+    }
 
-            this._name = this.constructor.name
-            this.container = options.container
-            this.viewer = options.viewer || options.container.firstElementChild
+    const pdfDocument = this._pdfDocument;
+    const {
+      type
+    } = state;
 
-            if (!(this.container?.tagName.toUpperCase() === 'DIV' && this.viewer?.tagName.toUpperCase() === 'DIV')) {
-              throw new Error('Invalid `container` and/or `viewer` option.')
-            }
+    if (this._state === null || this.#shouldDirtyMatch(state)) {
+      this._dirtyMatch = true;
+    }
 
-            if (this.container.offsetParent && getComputedStyle(this.container).position !== 'absolute') {
-              throw new Error('The `container` must be absolutely positioned.')
-            }
+    this._state = state;
 
-            this.eventBus = options.eventBus
-            this.linkService = options.linkService || new _pdf_link_service.SimpleLinkService()
-            this.downloadManager = options.downloadManager || null
-            this.findController = options.findController || null
-            this._scriptingManager = options.scriptingManager || null
-            this.removePageBorders = options.removePageBorders || false
-            this.textLayerMode = Number.isInteger(options.textLayerMode) ? options.textLayerMode : _ui_utils.TextLayerMode.ENABLE
-            this.imageResourcesPath = options.imageResourcesPath || ''
-            this.renderInteractiveForms = options.renderInteractiveForms !== false
-            this.enablePrintAutoRotate = options.enablePrintAutoRotate || false
-            this.renderer = options.renderer || _ui_utils.RendererType.CANVAS
-            this.enableWebGL = options.enableWebGL || false
-            this.useOnlyCssZoom = options.useOnlyCssZoom || false
-            this.maxCanvasPixels = options.maxCanvasPixels
-            this.l10n = options.l10n || _l10n_utils.NullL10n
-            this.enableScripting = options.enableScripting === true && !!this._scriptingManager
-            this.defaultRenderingQueue = !options.renderingQueue
-
-            if (this.defaultRenderingQueue) {
-              this.renderingQueue = new _pdf_rendering_queue.PDFRenderingQueue()
-              this.renderingQueue.setViewer(this)
-            } else {
-              this.renderingQueue = options.renderingQueue
-            }
+    if (type !== "highlightallchange") {
+      this.#updateUIState(FindState.PENDING);
+    }
 
-            this.scroll = (0, _ui_utils.watchScroll)(this.container, this._scrollUpdate.bind(this))
-            this.presentationModeState = _ui_utils.PresentationModeState.UNKNOWN
-            this._onBeforeDraw = this._onAfterDraw = null
+    this._firstPageCapability.promise.then(() => {
+      if (!this._pdfDocument || pdfDocument && this._pdfDocument !== pdfDocument) {
+        return;
+      }
 
-            this._resetView()
+      this.#extractText();
+      const findbarClosed = !this._highlightMatches;
+      const pendingTimeout = !!this._findTimeout;
 
-            if (this.removePageBorders) {
-              this.viewer.classList.add('removePageBorders')
-            }
+      if (this._findTimeout) {
+        clearTimeout(this._findTimeout);
+        this._findTimeout = null;
+      }
 
-            Promise.resolve().then(() => {
-              this.eventBus.dispatch('baseviewerinit', {
-                source: this
-              })
-            })
-          }
+      if (!type) {
+        this._findTimeout = setTimeout(() => {
+          this.#nextMatch();
+          this._findTimeout = null;
+        }, FIND_TIMEOUT);
+      } else if (this._dirtyMatch) {
+        this.#nextMatch();
+      } else if (type === "again") {
+        this.#nextMatch();
+
+        if (findbarClosed && this._state.highlightAll) {
+          this.#updateAllPages();
+        }
+      } else if (type === "highlightallchange") {
+        if (pendingTimeout) {
+          this.#nextMatch();
+        } else {
+          this._highlightMatches = true;
+        }
 
-          get pagesCount () {
-            return this._pages.length
-          }
+        this.#updateAllPages();
+      } else {
+        this.#nextMatch();
+      }
+    });
+  }
+
+  scrollMatchIntoView({
+    element = null,
+    selectedLeft = 0,
+    pageIndex = -1,
+    matchIndex = -1
+  }) {
+    if (!this._scrollMatches || !element) {
+      return;
+    } else if (matchIndex === -1 || matchIndex !== this._selected.matchIdx) {
+      return;
+    } else if (pageIndex === -1 || pageIndex !== this._selected.pageIdx) {
+      return;
+    }
 
-          getPageView (index) {
-            return this._pages[index]
-          }
+    this._scrollMatches = false;
+    const spot = {
+      top: MATCH_SCROLL_OFFSET_TOP,
+      left: selectedLeft + MATCH_SCROLL_OFFSET_LEFT
+    };
+    (0, _ui_utils.scrollIntoView)(element, spot, true);
+  }
+
+  #reset() {
+    this._highlightMatches = false;
+    this._scrollMatches = false;
+    this._pdfDocument = null;
+    this._pageMatches = [];
+    this._pageMatchesLength = [];
+    this._state = null;
+    this._selected = {
+      pageIdx: -1,
+      matchIdx: -1
+    };
+    this._offset = {
+      pageIdx: null,
+      matchIdx: null,
+      wrapped: false
+    };
+    this._extractTextPromises = [];
+    this._pageContents = [];
+    this._pageDiffs = [];
+    this._hasDiacritics = [];
+    this._matchesCountTotal = 0;
+    this._pagesToSearch = null;
+    this._pendingFindMatches = new Set();
+    this._resumePageIdx = null;
+    this._dirtyMatch = false;
+    clearTimeout(this._findTimeout);
+    this._findTimeout = null;
+    this._firstPageCapability = (0, _pdfjsLib.createPromiseCapability)();
+  }
+
+  get #query() {
+    if (this._state.query !== this._rawQuery) {
+      this._rawQuery = this._state.query;
+      [this._normalizedQuery] = normalize(this._state.query);
+    }
 
-          get pageViewsReady () {
-            if (!this._pagesCapability.settled) {
-              return false
-            }
+    return this._normalizedQuery;
+  }
 
-            return this._pages.every(function (pageView) {
-              return pageView?.pdfPage
-            })
-          }
+  #shouldDirtyMatch(state) {
+    if (state.query !== this._state.query) {
+      return true;
+    }
 
-          get currentPageNumber () {
-            return this._currentPageNumber
-          }
+    switch (state.type) {
+      case "again":
+        const pageNumber = this._selected.pageIdx + 1;
+        const linkService = this._linkService;
 
-          set currentPageNumber (val) {
-            if (!Number.isInteger(val)) {
-              throw new Error('Invalid page number.')
-            }
+        if (pageNumber >= 1 && pageNumber <= linkService.pagesCount && pageNumber !== linkService.page && !linkService.isPageVisible(pageNumber)) {
+          return true;
+        }
 
-            if (!this.pdfDocument) {
-              return
-            }
+        return false;
 
-            if (!this._setCurrentPageNumber(val, true)) {
-              console.error(`${this._name}.currentPageNumber: "${val}" is not a valid page.`)
-            }
-          }
+      case "highlightallchange":
+        return false;
+    }
 
-          _setCurrentPageNumber (val, resetCurrentPageView = false) {
-            if (this._currentPageNumber === val) {
-              if (resetCurrentPageView) {
-                this._resetCurrentPageView()
-              }
+    return true;
+  }
 
-              return true
-            }
+  #isEntireWord(content, startIdx, length) {
+    let match = content.slice(0, startIdx).match(NOT_DIACRITIC_FROM_END_REG_EXP);
 
-            if (!(0 < val && val <= this.pagesCount)) {
-              return false
-            }
+    if (match) {
+      const first = content.charCodeAt(startIdx);
+      const limit = match[1].charCodeAt(0);
 
-            const previous = this._currentPageNumber
-            this._currentPageNumber = val
-            this.eventBus.dispatch('pagechanging', {
-              source: this,
-              pageNumber: val,
-              pageLabel: this._pageLabels?.[val - 1] ?? null,
-              previous
-            })
-
-            if (resetCurrentPageView) {
-              this._resetCurrentPageView()
-            }
+      if ((0, _pdf_find_utils.getCharacterType)(first) === (0, _pdf_find_utils.getCharacterType)(limit)) {
+        return false;
+      }
+    }
 
-            return true
-          }
+    match = content.slice(startIdx + length).match(NOT_DIACRITIC_FROM_START_REG_EXP);
 
-          get currentPageLabel () {
-            return this._pageLabels?.[this._currentPageNumber - 1] ?? null
-          }
+    if (match) {
+      const last = content.charCodeAt(startIdx + length - 1);
+      const limit = match[1].charCodeAt(0);
 
-          set currentPageLabel (val) {
-            if (!this.pdfDocument) {
-              return
-            }
+      if ((0, _pdf_find_utils.getCharacterType)(last) === (0, _pdf_find_utils.getCharacterType)(limit)) {
+        return false;
+      }
+    }
 
-            let page = val | 0
+    return true;
+  }
 
-            if (this._pageLabels) {
-              const i = this._pageLabels.indexOf(val)
+  #calculateRegExpMatch(query, entireWord, pageIndex, pageContent) {
+    const matches = [],
+          matchesLength = [];
+    const diffs = this._pageDiffs[pageIndex];
+    let match;
 
-              if (i >= 0) {
-                page = i + 1
-              }
-            }
+    while ((match = query.exec(pageContent)) !== null) {
+      if (entireWord && !this.#isEntireWord(pageContent, match.index, match[0].length)) {
+        continue;
+      }
 
-            if (!this._setCurrentPageNumber(page, true)) {
-              console.error(`${this._name}.currentPageLabel: "${val}" is not a valid page.`)
-            }
-          }
+      const [matchPos, matchLen] = getOriginalIndex(diffs, match.index, match[0].length);
 
-          get currentScale () {
-            return this._currentScale !== _ui_utils.UNKNOWN_SCALE ? this._currentScale : _ui_utils.DEFAULT_SCALE
-          }
+      if (matchLen) {
+        matches.push(matchPos);
+        matchesLength.push(matchLen);
+      }
+    }
 
-          set currentScale (val) {
-            if (isNaN(val)) {
-              throw new Error('Invalid numeric scale.')
-            }
+    this._pageMatches[pageIndex] = matches;
+    this._pageMatchesLength[pageIndex] = matchesLength;
+  }
+
+  #convertToRegExpString(query, hasDiacritics) {
+    const {
+      matchDiacritics
+    } = this._state;
+    let isUnicode = false;
+    query = query.replace(SPECIAL_CHARS_REG_EXP, (match, p1, p2, p3, p4, p5) => {
+      if (p1) {
+        return `[ ]*\\${p1}[ ]*`;
+      }
 
-            if (!this.pdfDocument) {
-              return
-            }
+      if (p2) {
+        return `[ ]*${p2}[ ]*`;
+      }
 
-            this._setScale(val, false)
-          }
+      if (p3) {
+        return "[ ]+";
+      }
 
-          get currentScaleValue () {
-            return this._currentScaleValue
-          }
+      if (matchDiacritics) {
+        return p4 || p5;
+      }
 
-          set currentScaleValue (val) {
-            if (!this.pdfDocument) {
-              return
-            }
+      if (p4) {
+        return DIACRITICS_EXCEPTION.has(p4.charCodeAt(0)) ? p4 : "";
+      }
 
-            this._setScale(val, false)
-          }
+      if (hasDiacritics) {
+        isUnicode = true;
+        return `${p5}\\p{M}*`;
+      }
 
-          get pagesRotation () {
-            return this._pagesRotation
-          }
+      return p5;
+    });
+    const trailingSpaces = "[ ]*";
 
-          set pagesRotation (rotation) {
-            if (!(0, _ui_utils.isValidRotation)(rotation)) {
-              throw new Error('Invalid pages rotation angle.')
-            }
+    if (query.endsWith(trailingSpaces)) {
+      query = query.slice(0, query.length - trailingSpaces.length);
+    }
 
-            if (!this.pdfDocument) {
-              return
-            }
+    if (matchDiacritics) {
+      if (hasDiacritics) {
+        isUnicode = true;
+        query = `${query}(?=[${DIACRITICS_EXCEPTION_STR}]|[^\\p{M}]|$)`;
+      }
+    }
 
-            rotation %= 360
+    return [isUnicode, query];
+  }
 
-            if (rotation < 0) {
-              rotation += 360
-            }
+  #calculateMatch(pageIndex) {
+    let query = this.#query;
 
-            if (this._pagesRotation === rotation) {
-              return
-            }
+    if (query.length === 0) {
+      return;
+    }
 
-            this._pagesRotation = rotation
-            const pageNumber = this._currentPageNumber
+    const {
+      caseSensitive,
+      entireWord,
+      phraseSearch
+    } = this._state;
+    const pageContent = this._pageContents[pageIndex];
+    const hasDiacritics = this._hasDiacritics[pageIndex];
+    let isUnicode = false;
+
+    if (phraseSearch) {
+      [isUnicode, query] = this.#convertToRegExpString(query, hasDiacritics);
+    } else {
+      const match = query.match(/\S+/g);
+
+      if (match) {
+        query = match.sort().reverse().map(q => {
+          const [isUnicodePart, queryPart] = this.#convertToRegExpString(q, hasDiacritics);
+          isUnicode ||= isUnicodePart;
+          return `(${queryPart})`;
+        }).join("|");
+      }
+    }
 
-            for (let i = 0, ii = this._pages.length; i < ii; i++) {
-              const pageView = this._pages[i]
-              pageView.update(pageView.scale, rotation)
-            }
+    const flags = `g${isUnicode ? "u" : ""}${caseSensitive ? "" : "i"}`;
+    query = new RegExp(query, flags);
+    this.#calculateRegExpMatch(query, entireWord, pageIndex, pageContent);
 
-            if (this._currentScaleValue) {
-              this._setScale(this._currentScaleValue, true)
-            }
+    if (this._state.highlightAll) {
+      this.#updatePage(pageIndex);
+    }
 
-            this.eventBus.dispatch('rotationchanging', {
-              source: this,
-              pagesRotation: rotation,
-              pageNumber
-            })
+    if (this._resumePageIdx === pageIndex) {
+      this._resumePageIdx = null;
+      this.#nextPageMatch();
+    }
 
-            if (this.defaultRenderingQueue) {
-              this.update()
-            }
-          }
+    const pageMatchesCount = this._pageMatches[pageIndex].length;
 
-          get firstPagePromise () {
-            return this.pdfDocument ? this._firstPageCapability.promise : null
-          }
+    if (pageMatchesCount > 0) {
+      this._matchesCountTotal += pageMatchesCount;
+      this.#updateUIResultsCount();
+    }
+  }
 
-          get onePageRendered () {
-            return this.pdfDocument ? this._onePageRenderedCapability.promise : null
-          }
+  #extractText() {
+    if (this._extractTextPromises.length > 0) {
+      return;
+    }
 
-          get pagesPromise () {
-            return this.pdfDocument ? this._pagesCapability.promise : null
-          }
+    let promise = Promise.resolve();
 
-          get _viewerElement () {
-            throw new Error('Not implemented: _viewerElement')
-          }
+    for (let i = 0, ii = this._linkService.pagesCount; i < ii; i++) {
+      const extractTextCapability = (0, _pdfjsLib.createPromiseCapability)();
+      this._extractTextPromises[i] = extractTextCapability.promise;
+      promise = promise.then(() => {
+        return this._pdfDocument.getPage(i + 1).then(pdfPage => {
+          return pdfPage.getTextContent();
+        }).then(textContent => {
+          const strBuf = [];
 
-          _onePageRenderedOrForceFetch () {
-            if (!this.container.offsetParent || this._getVisiblePages().views.length === 0) {
-              return Promise.resolve()
-            }
+          for (const textItem of textContent.items) {
+            strBuf.push(textItem.str);
 
-            return this._onePageRenderedCapability.promise
+            if (textItem.hasEOL) {
+              strBuf.push("\n");
+            }
           }
 
-          setDocument (pdfDocument) {
-            if (this.pdfDocument) {
-              this.eventBus.dispatch('pagesdestroy', {
-                source: this
-              })
-
-              this._cancelRendering()
+          [this._pageContents[i], this._pageDiffs[i], this._hasDiacritics[i]] = normalize(strBuf.join(""));
+          extractTextCapability.resolve();
+        }, reason => {
+          console.error(`Unable to get text content for page ${i + 1}`, reason);
+          this._pageContents[i] = "";
+          this._pageDiffs[i] = null;
+          this._hasDiacritics[i] = false;
+          extractTextCapability.resolve();
+        });
+      });
+    }
+  }
 
-              this._resetView()
+  #updatePage(index) {
+    if (this._scrollMatches && this._selected.pageIdx === index) {
+      this._linkService.page = index + 1;
+    }
 
-              if (this.findController) {
-                this.findController.setDocument(null)
-              }
+    this._eventBus.dispatch("updatetextlayermatches", {
+      source: this,
+      pageIndex: index
+    });
+  }
+
+  #updateAllPages() {
+    this._eventBus.dispatch("updatetextlayermatches", {
+      source: this,
+      pageIndex: -1
+    });
+  }
+
+  #nextMatch() {
+    const previous = this._state.findPrevious;
+    const currentPageIndex = this._linkService.page - 1;
+    const numPages = this._linkService.pagesCount;
+    this._highlightMatches = true;
+
+    if (this._dirtyMatch) {
+      this._dirtyMatch = false;
+      this._selected.pageIdx = this._selected.matchIdx = -1;
+      this._offset.pageIdx = currentPageIndex;
+      this._offset.matchIdx = null;
+      this._offset.wrapped = false;
+      this._resumePageIdx = null;
+      this._pageMatches.length = 0;
+      this._pageMatchesLength.length = 0;
+      this._matchesCountTotal = 0;
+      this.#updateAllPages();
+
+      for (let i = 0; i < numPages; i++) {
+        if (this._pendingFindMatches.has(i)) {
+          continue;
+        }
 
-              if (this._scriptingManager) {
-                this._scriptingManager.setDocument(null)
-              }
-            }
+        this._pendingFindMatches.add(i);
 
-            this.pdfDocument = pdfDocument
+        this._extractTextPromises[i].then(() => {
+          this._pendingFindMatches.delete(i);
 
-            if (!pdfDocument) {
-              return
-            }
+          this.#calculateMatch(i);
+        });
+      }
+    }
 
-            const isPureXfa = pdfDocument.isPureXfa
-            const pagesCount = pdfDocument.numPages
-            const firstPagePromise = pdfDocument.getPage(1)
-            const optionalContentConfigPromise = pdfDocument.getOptionalContentConfig()
+    if (this.#query === "") {
+      this.#updateUIState(FindState.FOUND);
+      return;
+    }
 
-            this._pagesCapability.promise.then(() => {
-              this.eventBus.dispatch('pagesloaded', {
-                source: this,
-                pagesCount
-              })
-            })
+    if (this._resumePageIdx) {
+      return;
+    }
 
-            this._onBeforeDraw = evt => {
-              const pageView = this._pages[evt.pageNumber - 1]
+    const offset = this._offset;
+    this._pagesToSearch = numPages;
 
-              if (!pageView) {
-                return
-              }
+    if (offset.matchIdx !== null) {
+      const numPageMatches = this._pageMatches[offset.pageIdx].length;
 
-              this._buffer.push(pageView)
-            }
+      if (!previous && offset.matchIdx + 1 < numPageMatches || previous && offset.matchIdx > 0) {
+        offset.matchIdx = previous ? offset.matchIdx - 1 : offset.matchIdx + 1;
+        this.#updateMatch(true);
+        return;
+      }
 
-            this.eventBus._on('pagerender', this._onBeforeDraw)
+      this.#advanceOffsetPage(previous);
+    }
 
-            this._onAfterDraw = evt => {
-              if (evt.cssTransform || this._onePageRenderedCapability.settled) {
-                return
-              }
+    this.#nextPageMatch();
+  }
 
-              this._onePageRenderedCapability.resolve()
+  #matchesReady(matches) {
+    const offset = this._offset;
+    const numMatches = matches.length;
+    const previous = this._state.findPrevious;
 
-              this.eventBus._off('pagerendered', this._onAfterDraw)
+    if (numMatches) {
+      offset.matchIdx = previous ? numMatches - 1 : 0;
+      this.#updateMatch(true);
+      return true;
+    }
 
-              this._onAfterDraw = null
-            }
+    this.#advanceOffsetPage(previous);
 
-            this.eventBus._on('pagerendered', this._onAfterDraw)
-
-            firstPagePromise.then(firstPdfPage => {
-              this._firstPageCapability.resolve(firstPdfPage)
-
-              this._optionalContentConfigPromise = optionalContentConfigPromise
-              const scale = this.currentScale
-              const viewport = firstPdfPage.getViewport({
-                scale: scale * _ui_utils.CSS_UNITS
-              })
-              const textLayerFactory = this.textLayerMode !== _ui_utils.TextLayerMode.DISABLE ? this : null
-              const xfaLayerFactory = isPureXfa ? this : null
-
-              for (let pageNum = 1; pageNum <= pagesCount; ++pageNum) {
-                const pageView = new _pdf_page_view.PDFPageView({
-                  container: this._viewerElement,
-                  eventBus: this.eventBus,
-                  id: pageNum,
-                  scale,
-                  defaultViewport: viewport.clone(),
-                  optionalContentConfigPromise,
-                  renderingQueue: this.renderingQueue,
-                  textLayerFactory,
-                  textLayerMode: this.textLayerMode,
-                  annotationLayerFactory: this,
-                  xfaLayerFactory,
-                  imageResourcesPath: this.imageResourcesPath,
-                  renderInteractiveForms: this.renderInteractiveForms,
-                  renderer: this.renderer,
-                  enableWebGL: this.enableWebGL,
-                  useOnlyCssZoom: this.useOnlyCssZoom,
-                  maxCanvasPixels: this.maxCanvasPixels,
-                  l10n: this.l10n,
-                  enableScripting: this.enableScripting
-                })
-
-                this._pages.push(pageView)
-              }
+    if (offset.wrapped) {
+      offset.matchIdx = null;
 
-              const firstPageView = this._pages[0]
+      if (this._pagesToSearch < 0) {
+        this.#updateMatch(false);
+        return true;
+      }
+    }
 
-              if (firstPageView) {
-                firstPageView.setPdfPage(firstPdfPage)
-                this.linkService.cachePageRef(1, firstPdfPage.ref)
-              }
+    return false;
+  }
 
-              if (this._spreadMode !== _ui_utils.SpreadMode.NONE) {
-                this._updateSpreadMode()
-              }
+  #nextPageMatch() {
+    if (this._resumePageIdx !== null) {
+      console.error("There can only be one pending page.");
+    }
 
-              this._onePageRenderedOrForceFetch().then(() => {
-                if (this.findController) {
-                  this.findController.setDocument(pdfDocument)
-                }
+    let matches = null;
 
-                if (this.enableScripting) {
-                  this._scriptingManager.setDocument(pdfDocument)
-                }
+    do {
+      const pageIdx = this._offset.pageIdx;
+      matches = this._pageMatches[pageIdx];
 
-                if (pdfDocument.loadingParams.disableAutoFetch || pagesCount > 7500) {
-                  this._pagesCapability.resolve()
+      if (!matches) {
+        this._resumePageIdx = pageIdx;
+        break;
+      }
+    } while (!this.#matchesReady(matches));
+  }
+
+  #advanceOffsetPage(previous) {
+    const offset = this._offset;
+    const numPages = this._linkService.pagesCount;
+    offset.pageIdx = previous ? offset.pageIdx - 1 : offset.pageIdx + 1;
+    offset.matchIdx = null;
+    this._pagesToSearch--;
+
+    if (offset.pageIdx >= numPages || offset.pageIdx < 0) {
+      offset.pageIdx = previous ? numPages - 1 : 0;
+      offset.wrapped = true;
+    }
+  }
 
-                  return
-                }
+  #updateMatch(found = false) {
+    let state = FindState.NOT_FOUND;
+    const wrapped = this._offset.wrapped;
+    this._offset.wrapped = false;
 
-                let getPagesLeft = pagesCount - 1
+    if (found) {
+      const previousPage = this._selected.pageIdx;
+      this._selected.pageIdx = this._offset.pageIdx;
+      this._selected.matchIdx = this._offset.matchIdx;
+      state = wrapped ? FindState.WRAPPED : FindState.FOUND;
 
-                if (getPagesLeft <= 0) {
-                  this._pagesCapability.resolve()
+      if (previousPage !== -1 && previousPage !== this._selected.pageIdx) {
+        this.#updatePage(previousPage);
+      }
+    }
 
-                  return
-                }
+    this.#updateUIState(state, this._state.findPrevious);
 
-                for (let pageNum = 2; pageNum <= pagesCount; ++pageNum) {
-                  pdfDocument.getPage(pageNum).then(pdfPage => {
-                    const pageView = this._pages[pageNum - 1]
+    if (this._selected.pageIdx !== -1) {
+      this._scrollMatches = true;
+      this.#updatePage(this._selected.pageIdx);
+    }
+  }
 
-                    if (!pageView.pdfPage) {
-                      pageView.setPdfPage(pdfPage)
-                    }
+  #onFindBarClose(evt) {
+    const pdfDocument = this._pdfDocument;
 
-                    this.linkService.cachePageRef(pageNum, pdfPage.ref)
+    this._firstPageCapability.promise.then(() => {
+      if (!this._pdfDocument || pdfDocument && this._pdfDocument !== pdfDocument) {
+        return;
+      }
 
-                    if (--getPagesLeft === 0) {
-                      this._pagesCapability.resolve()
-                    }
-                  }, reason => {
-                    console.error(`Unable to get page ${pageNum} to initialize viewer`, reason)
+      if (this._findTimeout) {
+        clearTimeout(this._findTimeout);
+        this._findTimeout = null;
+      }
 
-                    if (--getPagesLeft === 0) {
-                      this._pagesCapability.resolve()
-                    }
-                  })
-                }
-              })
+      if (this._resumePageIdx) {
+        this._resumePageIdx = null;
+        this._dirtyMatch = true;
+      }
 
-              this.eventBus.dispatch('pagesinit', {
-                source: this
-              })
+      this.#updateUIState(FindState.FOUND);
+      this._highlightMatches = false;
+      this.#updateAllPages();
+    });
+  }
+
+  #requestMatchesCount() {
+    const {
+      pageIdx,
+      matchIdx
+    } = this._selected;
+    let current = 0,
+        total = this._matchesCountTotal;
+
+    if (matchIdx !== -1) {
+      for (let i = 0; i < pageIdx; i++) {
+        current += this._pageMatches[i]?.length || 0;
+      }
 
-              if (this.defaultRenderingQueue) {
-                this.update()
-              }
-            }).catch(reason => {
-              console.error('Unable to initialize viewer', reason)
-            })
-          }
+      current += matchIdx + 1;
+    }
 
-          setPageLabels (labels) {
-            if (!this.pdfDocument) {
-              return
-            }
+    if (current < 1 || current > total) {
+      current = total = 0;
+    }
 
-            if (!labels) {
-              this._pageLabels = null
-            } else if (!(Array.isArray(labels) && this.pdfDocument.numPages === labels.length)) {
-              this._pageLabels = null
-              console.error(`${this._name}.setPageLabels: Invalid page labels.`)
-            } else {
-              this._pageLabels = labels
-            }
+    return {
+      current,
+      total
+    };
+  }
+
+  #updateUIResultsCount() {
+    this._eventBus.dispatch("updatefindmatchescount", {
+      source: this,
+      matchesCount: this.#requestMatchesCount()
+    });
+  }
+
+  #updateUIState(state, previous = false) {
+    this._eventBus.dispatch("updatefindcontrolstate", {
+      source: this,
+      state,
+      previous,
+      matchesCount: this.#requestMatchesCount(),
+      rawQuery: this._state?.query ?? null
+    });
+  }
+
+}
+
+exports.PDFFindController = PDFFindController;
+
+/***/ }),
+/* 21 */
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.CharacterType = void 0;
+exports.getCharacterType = getCharacterType;
+const CharacterType = {
+  SPACE: 0,
+  ALPHA_LETTER: 1,
+  PUNCT: 2,
+  HAN_LETTER: 3,
+  KATAKANA_LETTER: 4,
+  HIRAGANA_LETTER: 5,
+  HALFWIDTH_KATAKANA_LETTER: 6,
+  THAI_LETTER: 7
+};
+exports.CharacterType = CharacterType;
+
+function isAlphabeticalScript(charCode) {
+  return charCode < 0x2e80;
+}
+
+function isAscii(charCode) {
+  return (charCode & 0xff80) === 0;
+}
+
+function isAsciiAlpha(charCode) {
+  return charCode >= 0x61 && charCode <= 0x7a || charCode >= 0x41 && charCode <= 0x5a;
+}
+
+function isAsciiDigit(charCode) {
+  return charCode >= 0x30 && charCode <= 0x39;
+}
+
+function isAsciiSpace(charCode) {
+  return charCode === 0x20 || charCode === 0x09 || charCode === 0x0d || charCode === 0x0a;
+}
+
+function isHan(charCode) {
+  return charCode >= 0x3400 && charCode <= 0x9fff || charCode >= 0xf900 && charCode <= 0xfaff;
+}
+
+function isKatakana(charCode) {
+  return charCode >= 0x30a0 && charCode <= 0x30ff;
+}
+
+function isHiragana(charCode) {
+  return charCode >= 0x3040 && charCode <= 0x309f;
+}
+
+function isHalfwidthKatakana(charCode) {
+  return charCode >= 0xff60 && charCode <= 0xff9f;
+}
+
+function isThai(charCode) {
+  return (charCode & 0xff80) === 0x0e00;
+}
+
+function getCharacterType(charCode) {
+  if (isAlphabeticalScript(charCode)) {
+    if (isAscii(charCode)) {
+      if (isAsciiSpace(charCode)) {
+        return CharacterType.SPACE;
+      } else if (isAsciiAlpha(charCode) || isAsciiDigit(charCode) || charCode === 0x5f) {
+        return CharacterType.ALPHA_LETTER;
+      }
 
-            for (let i = 0, ii = this._pages.length; i < ii; i++) {
-              this._pages[i].setPageLabel(this._pageLabels?.[i] ?? null)
-            }
-          }
+      return CharacterType.PUNCT;
+    } else if (isThai(charCode)) {
+      return CharacterType.THAI_LETTER;
+    } else if (charCode === 0xa0) {
+      return CharacterType.SPACE;
+    }
 
-          _resetView () {
-            this._pages = []
-            this._currentPageNumber = 1
-            this._currentScale = _ui_utils.UNKNOWN_SCALE
-            this._currentScaleValue = null
-            this._pageLabels = null
-            this._buffer = new PDFPageViewBuffer(DEFAULT_CACHE_SIZE)
-            this._location = null
-            this._pagesRotation = 0
-            this._optionalContentConfigPromise = null
-            this._pagesRequests = new WeakMap()
-            this._firstPageCapability = (0, _pdfjsLib.createPromiseCapability)()
-            this._onePageRenderedCapability = (0, _pdfjsLib.createPromiseCapability)()
-            this._pagesCapability = (0, _pdfjsLib.createPromiseCapability)()
-            this._scrollMode = _ui_utils.ScrollMode.VERTICAL
-            this._spreadMode = _ui_utils.SpreadMode.NONE
-
-            if (this._onBeforeDraw) {
-              this.eventBus._off('pagerender', this._onBeforeDraw)
-
-              this._onBeforeDraw = null
-            }
+    return CharacterType.ALPHA_LETTER;
+  }
+
+  if (isHan(charCode)) {
+    return CharacterType.HAN_LETTER;
+  } else if (isKatakana(charCode)) {
+    return CharacterType.KATAKANA_LETTER;
+  } else if (isHiragana(charCode)) {
+    return CharacterType.HIRAGANA_LETTER;
+  } else if (isHalfwidthKatakana(charCode)) {
+    return CharacterType.HALFWIDTH_KATAKANA_LETTER;
+  }
+
+  return CharacterType.ALPHA_LETTER;
+}
+
+/***/ }),
+/* 22 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDFHistory = void 0;
+exports.isDestArraysEqual = isDestArraysEqual;
+exports.isDestHashesEqual = isDestHashesEqual;
+
+var _ui_utils = __w_pdfjs_require__(6);
+
+var _event_utils = __w_pdfjs_require__(17);
+
+const HASH_CHANGE_TIMEOUT = 1000;
+const POSITION_UPDATED_THRESHOLD = 50;
+const UPDATE_VIEWAREA_TIMEOUT = 1000;
+
+function getCurrentHash() {
+  return document.location.hash;
+}
+
+class PDFHistory {
+  constructor({
+    linkService,
+    eventBus
+  }) {
+    this.linkService = linkService;
+    this.eventBus = eventBus;
+    this._initialized = false;
+    this._fingerprint = "";
+    this.reset();
+    this._boundEvents = null;
+
+    this.eventBus._on("pagesinit", () => {
+      this._isPagesLoaded = false;
+
+      this.eventBus._on("pagesloaded", evt => {
+        this._isPagesLoaded = !!evt.pagesCount;
+      }, {
+        once: true
+      });
+    });
+  }
+
+  initialize({
+    fingerprint,
+    resetHistory = false,
+    updateUrl = false
+  }) {
+    if (!fingerprint || typeof fingerprint !== "string") {
+      console.error('PDFHistory.initialize: The "fingerprint" must be a non-empty string.');
+      return;
+    }
 
-            if (this._onAfterDraw) {
-              this.eventBus._off('pagerendered', this._onAfterDraw)
+    if (this._initialized) {
+      this.reset();
+    }
 
-              this._onAfterDraw = null
-            }
+    const reInitialized = this._fingerprint !== "" && this._fingerprint !== fingerprint;
+    this._fingerprint = fingerprint;
+    this._updateUrl = updateUrl === true;
+    this._initialized = true;
+
+    this._bindEvents();
+
+    const state = window.history.state;
+    this._popStateInProgress = false;
+    this._blockHashChange = 0;
+    this._currentHash = getCurrentHash();
+    this._numPositionUpdates = 0;
+    this._uid = this._maxUid = 0;
+    this._destination = null;
+    this._position = null;
+
+    if (!this._isValidState(state, true) || resetHistory) {
+      const {
+        hash,
+        page,
+        rotation
+      } = this._parseCurrentHash(true);
+
+      if (!hash || reInitialized || resetHistory) {
+        this._pushOrReplaceState(null, true);
+
+        return;
+      }
 
-            this.viewer.textContent = ''
+      this._pushOrReplaceState({
+        hash,
+        page,
+        rotation
+      }, true);
 
-            this._updateScrollMode()
-          }
+      return;
+    }
 
-          _scrollUpdate () {
-            if (this.pagesCount === 0) {
-              return
-            }
+    const destination = state.destination;
 
-            this.update()
-          }
+    this._updateInternalState(destination, state.uid, true);
 
-          _scrollIntoView ({
-            pageDiv,
-            pageSpot = null,
-            pageNumber = null
-          }) {
-            (0, _ui_utils.scrollIntoView)(pageDiv, pageSpot)
-          }
+    if (destination.rotation !== undefined) {
+      this._initialRotation = destination.rotation;
+    }
 
-          _setScaleUpdatePages (newScale, newValue, noScroll = false, preset = false) {
-            this._currentScaleValue = newValue.toString()
+    if (destination.dest) {
+      this._initialBookmark = JSON.stringify(destination.dest);
+      this._destination.page = null;
+    } else if (destination.hash) {
+      this._initialBookmark = destination.hash;
+    } else if (destination.page) {
+      this._initialBookmark = `page=${destination.page}`;
+    }
+  }
 
-            if (isSameScale(this._currentScale, newScale)) {
-              if (preset) {
-                this.eventBus.dispatch('scalechanging', {
-                  source: this,
-                  scale: newScale,
-                  presetValue: newValue
-                })
-              }
+  reset() {
+    if (this._initialized) {
+      this._pageHide();
 
-              return
-            }
+      this._initialized = false;
 
-            for (let i = 0, ii = this._pages.length; i < ii; i++) {
-              this._pages[i].update(newScale)
-            }
+      this._unbindEvents();
+    }
 
-            this._currentScale = newScale
+    if (this._updateViewareaTimeout) {
+      clearTimeout(this._updateViewareaTimeout);
+      this._updateViewareaTimeout = null;
+    }
 
-            if (!noScroll) {
-              let page = this._currentPageNumber,
-                dest
+    this._initialBookmark = null;
+    this._initialRotation = null;
+  }
+
+  push({
+    namedDest = null,
+    explicitDest,
+    pageNumber
+  }) {
+    if (!this._initialized) {
+      return;
+    }
 
-              if (this._location && !(this.isInPresentationMode || this.isChangingPresentationMode)) {
-                page = this._location.pageNumber
-                dest = [null, {
-                  name: 'XYZ'
-                }, this._location.left, this._location.top, null]
-              }
+    if (namedDest && typeof namedDest !== "string") {
+      console.error("PDFHistory.push: " + `"${namedDest}" is not a valid namedDest parameter.`);
+      return;
+    } else if (!Array.isArray(explicitDest)) {
+      console.error("PDFHistory.push: " + `"${explicitDest}" is not a valid explicitDest parameter.`);
+      return;
+    } else if (!this._isValidPage(pageNumber)) {
+      if (pageNumber !== null || this._destination) {
+        console.error("PDFHistory.push: " + `"${pageNumber}" is not a valid pageNumber parameter.`);
+        return;
+      }
+    }
 
-              this.scrollPageIntoView({
-                pageNumber: page,
-                destArray: dest,
-                allowNegativeOffset: true
-              })
-            }
+    const hash = namedDest || JSON.stringify(explicitDest);
 
-            this.eventBus.dispatch('scalechanging', {
-              source: this,
-              scale: newScale,
-              presetValue: preset ? newValue : undefined
-            })
+    if (!hash) {
+      return;
+    }
 
-            if (this.defaultRenderingQueue) {
-              this.update()
-            }
-          }
+    let forceReplace = false;
 
-          get _pageWidthScaleFactor () {
-            if (this._spreadMode !== _ui_utils.SpreadMode.NONE && this._scrollMode !== _ui_utils.ScrollMode.HORIZONTAL && !this.isInPresentationMode) {
-              return 2
-            }
+    if (this._destination && (isDestHashesEqual(this._destination.hash, hash) || isDestArraysEqual(this._destination.dest, explicitDest))) {
+      if (this._destination.page) {
+        return;
+      }
 
-            return 1
-          }
+      forceReplace = true;
+    }
 
-          _setScale (value, noScroll = false) {
-            let scale = parseFloat(value)
+    if (this._popStateInProgress && !forceReplace) {
+      return;
+    }
 
-            if (scale > 0) {
-              this._setScaleUpdatePages(scale, value, noScroll, false)
-            } else {
-              const currentPage = this._pages[this._currentPageNumber - 1]
+    this._pushOrReplaceState({
+      dest: explicitDest,
+      hash,
+      page: pageNumber,
+      rotation: this.linkService.rotation
+    }, forceReplace);
+
+    if (!this._popStateInProgress) {
+      this._popStateInProgress = true;
+      Promise.resolve().then(() => {
+        this._popStateInProgress = false;
+      });
+    }
+  }
 
-              if (!currentPage) {
-                return
-              }
+  pushPage(pageNumber) {
+    if (!this._initialized) {
+      return;
+    }
 
-              const noPadding = this.isInPresentationMode || this.removePageBorders
-              let hPadding = noPadding ? 0 : _ui_utils.SCROLLBAR_PADDING
-              let vPadding = noPadding ? 0 : _ui_utils.VERTICAL_PADDING
+    if (!this._isValidPage(pageNumber)) {
+      console.error(`PDFHistory.pushPage: "${pageNumber}" is not a valid page number.`);
+      return;
+    }
 
-              if (!noPadding && this._isScrollModeHorizontal) {
-                [hPadding, vPadding] = [vPadding, hPadding]
-              }
+    if (this._destination?.page === pageNumber) {
+      return;
+    }
 
-              const pageWidthScale = (this.container.clientWidth - hPadding) / currentPage.width * currentPage.scale / this._pageWidthScaleFactor
-              const pageHeightScale = (this.container.clientHeight - vPadding) / currentPage.height * currentPage.scale
+    if (this._popStateInProgress) {
+      return;
+    }
 
-              switch (value) {
-                case 'page-actual':
-                  scale = 1
-                  break
+    this._pushOrReplaceState({
+      dest: null,
+      hash: `page=${pageNumber}`,
+      page: pageNumber,
+      rotation: this.linkService.rotation
+    });
+
+    if (!this._popStateInProgress) {
+      this._popStateInProgress = true;
+      Promise.resolve().then(() => {
+        this._popStateInProgress = false;
+      });
+    }
+  }
 
-                case 'page-width':
-                  scale = pageWidthScale
-                  break
+  pushCurrentPosition() {
+    if (!this._initialized || this._popStateInProgress) {
+      return;
+    }
 
-                case 'page-height':
-                  scale = pageHeightScale
-                  break
+    this._tryPushCurrentPosition();
+  }
 
-                case 'page-fit':
-                  scale = Math.min(pageWidthScale, pageHeightScale)
-                  break
+  back() {
+    if (!this._initialized || this._popStateInProgress) {
+      return;
+    }
 
-                case 'auto':
-                  const horizontalScale = (0, _ui_utils.isPortraitOrientation)(currentPage) ? pageWidthScale : Math.min(pageHeightScale, pageWidthScale)
-                  scale = Math.min(_ui_utils.MAX_AUTO_SCALE, horizontalScale)
-                  break
+    const state = window.history.state;
 
-                default:
-                  console.error(`${this._name}._setScale: "${value}" is an unknown zoom value.`)
-                  return
-              }
+    if (this._isValidState(state) && state.uid > 0) {
+      window.history.back();
+    }
+  }
 
-              this._setScaleUpdatePages(scale, value, noScroll, true)
-            }
-          }
+  forward() {
+    if (!this._initialized || this._popStateInProgress) {
+      return;
+    }
 
-          _resetCurrentPageView () {
-            if (this.isInPresentationMode) {
-              this._setScale(this._currentScaleValue, true)
-            }
+    const state = window.history.state;
 
-            const pageView = this._pages[this._currentPageNumber - 1]
+    if (this._isValidState(state) && state.uid < this._maxUid) {
+      window.history.forward();
+    }
+  }
 
-            this._scrollIntoView({
-              pageDiv: pageView.div
-            })
-          }
+  get popStateInProgress() {
+    return this._initialized && (this._popStateInProgress || this._blockHashChange > 0);
+  }
 
-          pageLabelToPageNumber (label) {
-            if (!this._pageLabels) {
-              return null
-            }
+  get initialBookmark() {
+    return this._initialized ? this._initialBookmark : null;
+  }
 
-            const i = this._pageLabels.indexOf(label)
+  get initialRotation() {
+    return this._initialized ? this._initialRotation : null;
+  }
 
-            if (i < 0) {
-              return null
-            }
+  _pushOrReplaceState(destination, forceReplace = false) {
+    const shouldReplace = forceReplace || !this._destination;
+    const newState = {
+      fingerprint: this._fingerprint,
+      uid: shouldReplace ? this._uid : this._uid + 1,
+      destination
+    };
 
-            return i + 1
-          }
+    this._updateInternalState(destination, newState.uid);
 
-          scrollPageIntoView ({
-            pageNumber,
-            destArray = null,
-            allowNegativeOffset = false,
-            ignoreDestinationZoom = false
-          }) {
-            if (!this.pdfDocument) {
-              return
-            }
+    let newUrl;
 
-            const pageView = Number.isInteger(pageNumber) && this._pages[pageNumber - 1]
+    if (this._updateUrl && destination?.hash) {
+      const baseUrl = document.location.href.split("#")[0];
 
-            if (!pageView) {
-              console.error(`${this._name}.scrollPageIntoView: ` + `"${pageNumber}" is not a valid pageNumber parameter.`)
-              return
-            }
+      if (!baseUrl.startsWith("file://")) {
+        newUrl = `${baseUrl}#${destination.hash}`;
+      }
+    }
 
-            if (this.isInPresentationMode || !destArray) {
-              this._setCurrentPageNumber(pageNumber, true)
+    if (shouldReplace) {
+      window.history.replaceState(newState, "", newUrl);
+    } else {
+      window.history.pushState(newState, "", newUrl);
+    }
+  }
 
-              return
-            }
+  _tryPushCurrentPosition(temporary = false) {
+    if (!this._position) {
+      return;
+    }
 
-            let x = 0,
-              y = 0
-            let width = 0,
-              height = 0,
-              widthScale,
-              heightScale
-            const changeOrientation = pageView.rotation % 180 !== 0
-            const pageWidth = (changeOrientation ? pageView.height : pageView.width) / pageView.scale / _ui_utils.CSS_UNITS
-            const pageHeight = (changeOrientation ? pageView.width : pageView.height) / pageView.scale / _ui_utils.CSS_UNITS
-            let scale = 0
-
-            switch (destArray[1].name) {
-              case 'XYZ':
-                x = destArray[2]
-                y = destArray[3]
-                scale = destArray[4]
-                x = x !== null ? x : 0
-                y = y !== null ? y : pageHeight
-                break
-
-              case 'Fit':
-              case 'FitB':
-                scale = 'page-fit'
-                break
-
-              case 'FitH':
-              case 'FitBH':
-                y = destArray[2]
-                scale = 'page-width'
-
-                if (y === null && this._location) {
-                  x = this._location.left
-                  y = this._location.top
-                } else if (typeof y !== 'number') {
-                  y = pageHeight
-                }
+    let position = this._position;
 
-                break
-
-              case 'FitV':
-              case 'FitBV':
-                x = destArray[2]
-                width = pageWidth
-                height = pageHeight
-                scale = 'page-height'
-                break
-
-              case 'FitR':
-                x = destArray[2]
-                y = destArray[3]
-                width = destArray[4] - x
-                height = destArray[5] - y
-                const hPadding = this.removePageBorders ? 0 : _ui_utils.SCROLLBAR_PADDING
-                const vPadding = this.removePageBorders ? 0 : _ui_utils.VERTICAL_PADDING
-                widthScale = (this.container.clientWidth - hPadding) / width / _ui_utils.CSS_UNITS
-                heightScale = (this.container.clientHeight - vPadding) / height / _ui_utils.CSS_UNITS
-                scale = Math.min(Math.abs(widthScale), Math.abs(heightScale))
-                break
-
-              default:
-                console.error(`${this._name}.scrollPageIntoView: ` + `"${destArray[1].name}" is not a valid destination type.`)
-                return
-            }
+    if (temporary) {
+      position = Object.assign(Object.create(null), this._position);
+      position.temporary = true;
+    }
 
-            if (!ignoreDestinationZoom) {
-              if (scale && scale !== this._currentScale) {
-                this.currentScaleValue = scale
-              } else if (this._currentScale === _ui_utils.UNKNOWN_SCALE) {
-                this.currentScaleValue = _ui_utils.DEFAULT_SCALE_VALUE
-              }
-            }
+    if (!this._destination) {
+      this._pushOrReplaceState(position);
 
-            if (scale === 'page-fit' && !destArray[4]) {
-              this._scrollIntoView({
-                pageDiv: pageView.div,
-                pageNumber
-              })
+      return;
+    }
 
-              return
-            }
+    if (this._destination.temporary) {
+      this._pushOrReplaceState(position, true);
 
-            const boundingRect = [pageView.viewport.convertToViewportPoint(x, y), pageView.viewport.convertToViewportPoint(x + width, y + height)]
-            let left = Math.min(boundingRect[0][0], boundingRect[1][0])
-            let top = Math.min(boundingRect[0][1], boundingRect[1][1])
+      return;
+    }
 
-            if (!allowNegativeOffset) {
-              left = Math.max(left, 0)
-              top = Math.max(top, 0)
-            }
+    if (this._destination.hash === position.hash) {
+      return;
+    }
 
-            this._scrollIntoView({
-              pageDiv: pageView.div,
-              pageSpot: {
-                left,
-                top
-              },
-              pageNumber
-            })
-          }
+    if (!this._destination.page && (POSITION_UPDATED_THRESHOLD <= 0 || this._numPositionUpdates <= POSITION_UPDATED_THRESHOLD)) {
+      return;
+    }
 
-          _updateLocation (firstPage) {
-            const currentScale = this._currentScale
-            const currentScaleValue = this._currentScaleValue
-            const normalizedScaleValue = parseFloat(currentScaleValue) === currentScale ? Math.round(currentScale * 10000) / 100 : currentScaleValue
-            const pageNumber = firstPage.id
-            let pdfOpenParams = '#page=' + pageNumber
-            pdfOpenParams += '&zoom=' + normalizedScaleValue
-            const currentPageView = this._pages[pageNumber - 1]
-            const container = this.container
-            const topLeft = currentPageView.getPagePoint(container.scrollLeft - firstPage.x, container.scrollTop - firstPage.y)
-            const intLeft = Math.round(topLeft[0])
-            const intTop = Math.round(topLeft[1])
-            pdfOpenParams += ',' + intLeft + ',' + intTop
-            this._location = {
-              pageNumber,
-              scale: normalizedScaleValue,
-              top: intTop,
-              left: intLeft,
-              rotation: this._pagesRotation,
-              pdfOpenParams
-            }
-          }
+    let forceReplace = false;
 
-          _updateHelper (visiblePages) {
-            throw new Error('Not implemented: _updateHelper')
-          }
+    if (this._destination.page >= position.first && this._destination.page <= position.page) {
+      if (this._destination.dest !== undefined || !this._destination.first) {
+        return;
+      }
 
-          update () {
-            const visible = this._getVisiblePages()
+      forceReplace = true;
+    }
 
-            const visiblePages = visible.views,
-              numVisiblePages = visiblePages.length
+    this._pushOrReplaceState(position, forceReplace);
+  }
 
-            if (numVisiblePages === 0) {
-              return
-            }
+  _isValidPage(val) {
+    return Number.isInteger(val) && val > 0 && val <= this.linkService.pagesCount;
+  }
 
-            const newCacheSize = Math.max(DEFAULT_CACHE_SIZE, 2 * numVisiblePages + 1)
+  _isValidState(state, checkReload = false) {
+    if (!state) {
+      return false;
+    }
 
-            this._buffer.resize(newCacheSize, visiblePages)
+    if (state.fingerprint !== this._fingerprint) {
+      if (checkReload) {
+        if (typeof state.fingerprint !== "string" || state.fingerprint.length !== this._fingerprint.length) {
+          return false;
+        }
 
-            this.renderingQueue.renderHighestPriority(visible)
+        const [perfEntry] = performance.getEntriesByType("navigation");
 
-            this._updateHelper(visiblePages)
+        if (perfEntry?.type !== "reload") {
+          return false;
+        }
+      } else {
+        return false;
+      }
+    }
 
-            this._updateLocation(visible.first)
+    if (!Number.isInteger(state.uid) || state.uid < 0) {
+      return false;
+    }
 
-            this.eventBus.dispatch('updateviewarea', {
-              source: this,
-              location: this._location
-            })
-          }
+    if (state.destination === null || typeof state.destination !== "object") {
+      return false;
+    }
 
-          containsElement (element) {
-            return this.container.contains(element)
-          }
+    return true;
+  }
 
-          focus () {
-            this.container.focus()
-          }
+  _updateInternalState(destination, uid, removeTemporary = false) {
+    if (this._updateViewareaTimeout) {
+      clearTimeout(this._updateViewareaTimeout);
+      this._updateViewareaTimeout = null;
+    }
 
-          get _isScrollModeHorizontal () {
-            return this.isInPresentationMode ? false : this._scrollMode === _ui_utils.ScrollMode.HORIZONTAL
-          }
+    if (removeTemporary && destination?.temporary) {
+      delete destination.temporary;
+    }
 
-          get _isContainerRtl () {
-            return getComputedStyle(this.container).direction === 'rtl'
-          }
+    this._destination = destination;
+    this._uid = uid;
+    this._maxUid = Math.max(this._maxUid, uid);
+    this._numPositionUpdates = 0;
+  }
 
-          get isInPresentationMode () {
-            return this.presentationModeState === _ui_utils.PresentationModeState.FULLSCREEN
-          }
+  _parseCurrentHash(checkNameddest = false) {
+    const hash = unescape(getCurrentHash()).substring(1);
+    const params = (0, _ui_utils.parseQueryString)(hash);
+    const nameddest = params.get("nameddest") || "";
+    let page = params.get("page") | 0;
 
-          get isChangingPresentationMode () {
-            return this.presentationModeState === _ui_utils.PresentationModeState.CHANGING
-          }
+    if (!this._isValidPage(page) || checkNameddest && nameddest.length > 0) {
+      page = null;
+    }
 
-          get isHorizontalScrollbarEnabled () {
-            return this.isInPresentationMode ? false : this.container.scrollWidth > this.container.clientWidth
-          }
+    return {
+      hash,
+      page,
+      rotation: this.linkService.rotation
+    };
+  }
+
+  _updateViewarea({
+    location
+  }) {
+    if (this._updateViewareaTimeout) {
+      clearTimeout(this._updateViewareaTimeout);
+      this._updateViewareaTimeout = null;
+    }
 
-          get isVerticalScrollbarEnabled () {
-            return this.isInPresentationMode ? false : this.container.scrollHeight > this.container.clientHeight
-          }
+    this._position = {
+      hash: location.pdfOpenParams.substring(1),
+      page: this.linkService.page,
+      first: location.pageNumber,
+      rotation: location.rotation
+    };
 
-          _getCurrentVisiblePage () {
-            if (!this.pagesCount) {
-              return {
-                views: []
-              }
-            }
+    if (this._popStateInProgress) {
+      return;
+    }
 
-            const pageView = this._pages[this._currentPageNumber - 1]
-            const element = pageView.div
-            const view = {
-              id: pageView.id,
-              x: element.offsetLeft + element.clientLeft,
-              y: element.offsetTop + element.clientTop,
-              view: pageView
-            }
-            return {
-              first: view,
-              last: view,
-              views: [view]
-            }
-          }
+    if (POSITION_UPDATED_THRESHOLD > 0 && this._isPagesLoaded && this._destination && !this._destination.page) {
+      this._numPositionUpdates++;
+    }
 
-          _getVisiblePages () {
-            return (0, _ui_utils.getVisibleElements)({
-              scrollEl: this.container,
-              views: this._pages,
-              sortByVisibility: true,
-              horizontal: this._isScrollModeHorizontal,
-              rtl: this._isScrollModeHorizontal && this._isContainerRtl
-            })
-          }
+    if (UPDATE_VIEWAREA_TIMEOUT > 0) {
+      this._updateViewareaTimeout = setTimeout(() => {
+        if (!this._popStateInProgress) {
+          this._tryPushCurrentPosition(true);
+        }
 
-          isPageVisible (pageNumber) {
-            if (!this.pdfDocument) {
-              return false
-            }
+        this._updateViewareaTimeout = null;
+      }, UPDATE_VIEWAREA_TIMEOUT);
+    }
+  }
+
+  _popState({
+    state
+  }) {
+    const newHash = getCurrentHash(),
+          hashChanged = this._currentHash !== newHash;
+    this._currentHash = newHash;
+
+    if (!state) {
+      this._uid++;
+
+      const {
+        hash,
+        page,
+        rotation
+      } = this._parseCurrentHash();
+
+      this._pushOrReplaceState({
+        hash,
+        page,
+        rotation
+      }, true);
+
+      return;
+    }
 
-            if (!(Number.isInteger(pageNumber) && pageNumber > 0 && pageNumber <= this.pagesCount)) {
-              console.error(`${this._name}.isPageVisible: "${pageNumber}" is not a valid page.`)
-              return false
-            }
+    if (!this._isValidState(state)) {
+      return;
+    }
 
-            return this._getVisiblePages().views.some(function (view) {
-              return view.id === pageNumber
-            })
-          }
+    this._popStateInProgress = true;
+
+    if (hashChanged) {
+      this._blockHashChange++;
+      (0, _event_utils.waitOnEventOrTimeout)({
+        target: window,
+        name: "hashchange",
+        delay: HASH_CHANGE_TIMEOUT
+      }).then(() => {
+        this._blockHashChange--;
+      });
+    }
 
-          isPageCached (pageNumber) {
-            if (!this.pdfDocument || !this._buffer) {
-              return false
-            }
+    const destination = state.destination;
 
-            if (!(Number.isInteger(pageNumber) && pageNumber > 0 && pageNumber <= this.pagesCount)) {
-              console.error(`${this._name}.isPageCached: "${pageNumber}" is not a valid page.`)
-              return false
-            }
+    this._updateInternalState(destination, state.uid, true);
 
-            const pageView = this._pages[pageNumber - 1]
+    if ((0, _ui_utils.isValidRotation)(destination.rotation)) {
+      this.linkService.rotation = destination.rotation;
+    }
 
-            if (!pageView) {
-              return false
-            }
+    if (destination.dest) {
+      this.linkService.goToDestination(destination.dest);
+    } else if (destination.hash) {
+      this.linkService.setHash(destination.hash);
+    } else if (destination.page) {
+      this.linkService.page = destination.page;
+    }
 
-            return this._buffer.has(pageView)
-          }
+    Promise.resolve().then(() => {
+      this._popStateInProgress = false;
+    });
+  }
 
-          cleanup () {
-            for (let i = 0, ii = this._pages.length; i < ii; i++) {
-              if (this._pages[i] && this._pages[i].renderingState !== _pdf_rendering_queue.RenderingStates.FINISHED) {
-                this._pages[i].reset()
-              }
-            }
-          }
+  _pageHide() {
+    if (!this._destination || this._destination.temporary) {
+      this._tryPushCurrentPosition();
+    }
+  }
 
-          _cancelRendering () {
-            for (let i = 0, ii = this._pages.length; i < ii; i++) {
-              if (this._pages[i]) {
-                this._pages[i].cancelRendering()
-              }
-            }
-          }
+  _bindEvents() {
+    if (this._boundEvents) {
+      return;
+    }
 
-          _ensurePdfPageLoaded (pageView) {
-            if (pageView.pdfPage) {
-              return Promise.resolve(pageView.pdfPage)
-            }
+    this._boundEvents = {
+      updateViewarea: this._updateViewarea.bind(this),
+      popState: this._popState.bind(this),
+      pageHide: this._pageHide.bind(this)
+    };
 
-            if (this._pagesRequests.has(pageView)) {
-              return this._pagesRequests.get(pageView)
-            }
+    this.eventBus._on("updateviewarea", this._boundEvents.updateViewarea);
 
-            const promise = this.pdfDocument.getPage(pageView.id).then(pdfPage => {
-              if (!pageView.pdfPage) {
-                pageView.setPdfPage(pdfPage)
-              }
+    window.addEventListener("popstate", this._boundEvents.popState);
+    window.addEventListener("pagehide", this._boundEvents.pageHide);
+  }
 
-              this._pagesRequests.delete(pageView)
+  _unbindEvents() {
+    if (!this._boundEvents) {
+      return;
+    }
 
-              return pdfPage
-            }).catch(reason => {
-              console.error('Unable to get page for page view', reason)
+    this.eventBus._off("updateviewarea", this._boundEvents.updateViewarea);
 
-              this._pagesRequests.delete(pageView)
-            })
+    window.removeEventListener("popstate", this._boundEvents.popState);
+    window.removeEventListener("pagehide", this._boundEvents.pageHide);
+    this._boundEvents = null;
+  }
 
-            this._pagesRequests.set(pageView, promise)
+}
 
-            return promise
-          }
+exports.PDFHistory = PDFHistory;
 
-          forceRendering (currentlyVisiblePages) {
-            const visiblePages = currentlyVisiblePages || this._getVisiblePages()
+function isDestHashesEqual(destHash, pushHash) {
+  if (typeof destHash !== "string" || typeof pushHash !== "string") {
+    return false;
+  }
 
-            const scrollAhead = this._isScrollModeHorizontal ? this.scroll.right : this.scroll.down
-            const pageView = this.renderingQueue.getHighestPriority(visiblePages, this._pages, scrollAhead)
+  if (destHash === pushHash) {
+    return true;
+  }
 
-            if (pageView) {
-              this._ensurePdfPageLoaded(pageView).then(() => {
-                this.renderingQueue.renderView(pageView)
-              })
+  const nameddest = (0, _ui_utils.parseQueryString)(destHash).get("nameddest");
 
-              return true
-            }
+  if (nameddest === pushHash) {
+    return true;
+  }
 
-            return false
-          }
+  return false;
+}
 
-          createTextLayerBuilder (textLayerDiv, pageIndex, viewport, enhanceTextSelection = false, eventBus) {
-            return new _text_layer_builder.TextLayerBuilder({
-              textLayerDiv,
-              eventBus,
-              pageIndex,
-              viewport,
-              findController: this.isInPresentationMode ? null : this.findController,
-              enhanceTextSelection: this.isInPresentationMode ? false : enhanceTextSelection
-            })
-          }
+function isDestArraysEqual(firstDest, secondDest) {
+  function isEntryEqual(first, second) {
+    if (typeof first !== typeof second) {
+      return false;
+    }
 
-          createAnnotationLayerBuilder (pageDiv, pdfPage, annotationStorage = null, imageResourcesPath = '', renderInteractiveForms = false, l10n = _l10n_utils.NullL10n, enableScripting = false, hasJSActionsPromise = null, mouseState = null) {
-            return new _annotation_layer_builder.AnnotationLayerBuilder({
-              pageDiv,
-              pdfPage,
-              annotationStorage: annotationStorage || this.pdfDocument?.annotationStorage,
-              imageResourcesPath,
-              renderInteractiveForms,
-              linkService: this.linkService,
-              downloadManager: this.downloadManager,
-              l10n,
-              enableScripting,
-              hasJSActionsPromise: hasJSActionsPromise || this.pdfDocument?.hasJSActions(),
-              mouseState: mouseState || this._scriptingManager?.mouseState
-            })
-          }
+    if (Array.isArray(first) || Array.isArray(second)) {
+      return false;
+    }
 
-          createXfaLayerBuilder (pageDiv, pdfPage) {
-            return new _xfa_layer_builder.XfaLayerBuilder({
-              pageDiv,
-              pdfPage
-            })
-          }
+    if (first !== null && typeof first === "object" && second !== null) {
+      if (Object.keys(first).length !== Object.keys(second).length) {
+        return false;
+      }
 
-          get hasEqualPageSizes () {
-            const firstPageView = this._pages[0]
+      for (const key in first) {
+        if (!isEntryEqual(first[key], second[key])) {
+          return false;
+        }
+      }
 
-            for (let i = 1, ii = this._pages.length; i < ii; ++i) {
-              const pageView = this._pages[i]
+      return true;
+    }
 
-              if (pageView.width !== firstPageView.width || pageView.height !== firstPageView.height) {
-                return false
-              }
-            }
+    return first === second || Number.isNaN(first) && Number.isNaN(second);
+  }
 
-            return true
-          }
+  if (!(Array.isArray(firstDest) && Array.isArray(secondDest))) {
+    return false;
+  }
 
-          getPagesOverview () {
-            return this._pages.map(pageView => {
-              const viewport = pageView.pdfPage.getViewport({
-                scale: 1
-              })
-
-              if (!this.enablePrintAutoRotate || (0, _ui_utils.isPortraitOrientation)(viewport)) {
-                return {
-                  width: viewport.width,
-                  height: viewport.height,
-                  rotation: viewport.rotation
-                }
-              }
+  if (firstDest.length !== secondDest.length) {
+    return false;
+  }
 
-              return {
-                width: viewport.height,
-                height: viewport.width,
-                rotation: (viewport.rotation - 90) % 360
-              }
-            })
-          }
+  for (let i = 0, ii = firstDest.length; i < ii; i++) {
+    if (!isEntryEqual(firstDest[i], secondDest[i])) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/***/ }),
+/* 23 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PDFScriptingManager = void 0;
+
+var _ui_utils = __w_pdfjs_require__(6);
+
+var _pdfjsLib = __w_pdfjs_require__(3);
+
+class PDFScriptingManager {
+  constructor({
+    eventBus,
+    sandboxBundleSrc = null,
+    scriptingFactory = null,
+    docPropertiesLookup = null
+  }) {
+    this._pdfDocument = null;
+    this._pdfViewer = null;
+    this._closeCapability = null;
+    this._destroyCapability = null;
+    this._scripting = null;
+    this._mouseState = Object.create(null);
+    this._ready = false;
+    this._eventBus = eventBus;
+    this._sandboxBundleSrc = sandboxBundleSrc;
+    this._scriptingFactory = scriptingFactory;
+    this._docPropertiesLookup = docPropertiesLookup;
+
+    if (!this._scriptingFactory) {
+      window.addEventListener("updatefromsandbox", event => {
+        this._eventBus.dispatch("updatefromsandbox", {
+          source: window,
+          detail: event.detail
+        });
+      });
+    }
+  }
 
-          get optionalContentConfigPromise () {
-            if (!this.pdfDocument) {
-              return Promise.resolve(null)
-            }
+  setViewer(pdfViewer) {
+    this._pdfViewer = pdfViewer;
+  }
 
-            if (!this._optionalContentConfigPromise) {
-              return this.pdfDocument.getOptionalContentConfig()
-            }
+  async setDocument(pdfDocument) {
+    if (this._pdfDocument) {
+      await this._destroyScripting();
+    }
 
-            return this._optionalContentConfigPromise
-          }
+    this._pdfDocument = pdfDocument;
 
-          set optionalContentConfigPromise (promise) {
-            if (!(promise instanceof Promise)) {
-              throw new Error(`Invalid optionalContentConfigPromise: ${promise}`)
-            }
+    if (!pdfDocument) {
+      return;
+    }
 
-            if (!this.pdfDocument) {
-              return
-            }
+    const [objects, calculationOrder, docActions] = await Promise.all([pdfDocument.getFieldObjects(), pdfDocument.getCalculationOrderIds(), pdfDocument.getJSActions()]);
 
-            if (!this._optionalContentConfigPromise) {
-              return
-            }
+    if (!objects && !docActions) {
+      await this._destroyScripting();
+      return;
+    }
 
-            this._optionalContentConfigPromise = promise
+    if (pdfDocument !== this._pdfDocument) {
+      return;
+    }
 
-            for (const pageView of this._pages) {
-              pageView.update(pageView.scale, pageView.rotation, promise)
-            }
+    try {
+      this._scripting = this._createScripting();
+    } catch (error) {
+      console.error(`PDFScriptingManager.setDocument: "${error?.message}".`);
+      await this._destroyScripting();
+      return;
+    }
 
-            this.update()
-            this.eventBus.dispatch('optionalcontentconfigchanged', {
-              source: this,
-              promise
-            })
-          }
+    this._internalEvents.set("updatefromsandbox", event => {
+      if (event?.source !== window) {
+        return;
+      }
 
-          get scrollMode () {
-            return this._scrollMode
-          }
+      this._updateFromSandbox(event.detail);
+    });
 
-          set scrollMode (mode) {
-            if (this._scrollMode === mode) {
-              return
-            }
+    this._internalEvents.set("dispatcheventinsandbox", event => {
+      this._scripting?.dispatchEventInSandbox(event.detail);
+    });
 
-            if (!(0, _ui_utils.isValidScrollMode)(mode)) {
-              throw new Error(`Invalid scroll mode: ${mode}`)
-            }
+    this._internalEvents.set("pagechanging", ({
+      pageNumber,
+      previous
+    }) => {
+      if (pageNumber === previous) {
+        return;
+      }
 
-            this._scrollMode = mode
-            this.eventBus.dispatch('scrollmodechanged', {
-              source: this,
-              mode
-            })
+      this._dispatchPageClose(previous);
 
-            this._updateScrollMode(this._currentPageNumber)
-          }
+      this._dispatchPageOpen(pageNumber);
+    });
 
-          _updateScrollMode (pageNumber = null) {
-            const scrollMode = this._scrollMode,
-              viewer = this.viewer
-            viewer.classList.toggle('scrollHorizontal', scrollMode === _ui_utils.ScrollMode.HORIZONTAL)
-            viewer.classList.toggle('scrollWrapped', scrollMode === _ui_utils.ScrollMode.WRAPPED)
+    this._internalEvents.set("pagerendered", ({
+      pageNumber
+    }) => {
+      if (!this._pageOpenPending.has(pageNumber)) {
+        return;
+      }
 
-            if (!this.pdfDocument || !pageNumber) {
-              return
-            }
+      if (pageNumber !== this._pdfViewer.currentPageNumber) {
+        return;
+      }
 
-            if (this._currentScaleValue && isNaN(this._currentScaleValue)) {
-              this._setScale(this._currentScaleValue, true)
-            }
+      this._dispatchPageOpen(pageNumber);
+    });
 
-            this._setCurrentPageNumber(pageNumber, true)
+    this._internalEvents.set("pagesdestroy", async event => {
+      await this._dispatchPageClose(this._pdfViewer.currentPageNumber);
+      await this._scripting?.dispatchEventInSandbox({
+        id: "doc",
+        name: "WillClose"
+      });
+      this._closeCapability?.resolve();
+    });
 
-            this.update()
-          }
+    this._domEvents.set("mousedown", event => {
+      this._mouseState.isDown = true;
+    });
 
-          get spreadMode () {
-            return this._spreadMode
-          }
+    this._domEvents.set("mouseup", event => {
+      this._mouseState.isDown = false;
+    });
 
-          set spreadMode (mode) {
-            if (this._spreadMode === mode) {
-              return
-            }
+    for (const [name, listener] of this._internalEvents) {
+      this._eventBus._on(name, listener);
+    }
 
-            if (!(0, _ui_utils.isValidSpreadMode)(mode)) {
-              throw new Error(`Invalid spread mode: ${mode}`)
-            }
+    for (const [name, listener] of this._domEvents) {
+      window.addEventListener(name, listener, true);
+    }
 
-            this._spreadMode = mode
-            this.eventBus.dispatch('spreadmodechanged', {
-              source: this,
-              mode
-            })
+    try {
+      const docProperties = await this._getDocProperties();
 
-            this._updateSpreadMode(this._currentPageNumber)
-          }
+      if (pdfDocument !== this._pdfDocument) {
+        return;
+      }
 
-          _updateSpreadMode (pageNumber = null) {
-            if (!this.pdfDocument) {
-              return
-            }
+      await this._scripting.createSandbox({
+        objects,
+        calculationOrder,
+        appInfo: {
+          platform: navigator.platform,
+          language: navigator.language
+        },
+        docInfo: { ...docProperties,
+          actions: docActions
+        }
+      });
+
+      this._eventBus.dispatch("sandboxcreated", {
+        source: this
+      });
+    } catch (error) {
+      console.error(`PDFScriptingManager.setDocument: "${error?.message}".`);
+      await this._destroyScripting();
+      return;
+    }
 
-            const viewer = this.viewer,
-              pages = this._pages
-            viewer.textContent = ''
+    await this._scripting?.dispatchEventInSandbox({
+      id: "doc",
+      name: "Open"
+    });
+    await this._dispatchPageOpen(this._pdfViewer.currentPageNumber, true);
+    Promise.resolve().then(() => {
+      if (pdfDocument === this._pdfDocument) {
+        this._ready = true;
+      }
+    });
+  }
+
+  async dispatchWillSave(detail) {
+    return this._scripting?.dispatchEventInSandbox({
+      id: "doc",
+      name: "WillSave"
+    });
+  }
+
+  async dispatchDidSave(detail) {
+    return this._scripting?.dispatchEventInSandbox({
+      id: "doc",
+      name: "DidSave"
+    });
+  }
+
+  async dispatchWillPrint(detail) {
+    return this._scripting?.dispatchEventInSandbox({
+      id: "doc",
+      name: "WillPrint"
+    });
+  }
+
+  async dispatchDidPrint(detail) {
+    return this._scripting?.dispatchEventInSandbox({
+      id: "doc",
+      name: "DidPrint"
+    });
+  }
+
+  get mouseState() {
+    return this._mouseState;
+  }
 
-            if (this._spreadMode === _ui_utils.SpreadMode.NONE) {
-              for (let i = 0, iMax = pages.length; i < iMax; ++i) {
-                viewer.appendChild(pages[i].div)
-              }
-            } else {
-              const parity = this._spreadMode - 1
-              let spread = null
-
-              for (let i = 0, iMax = pages.length; i < iMax; ++i) {
-                if (spread === null) {
-                  spread = document.createElement('div')
-                  spread.className = 'spread'
-                  viewer.appendChild(spread)
-                } else if (i % 2 === parity) {
-                  spread = spread.cloneNode(false)
-                  viewer.appendChild(spread)
-                }
+  get destroyPromise() {
+    return this._destroyCapability?.promise || null;
+  }
 
-                spread.appendChild(pages[i].div)
-              }
-            }
+  get ready() {
+    return this._ready;
+  }
 
-            if (!pageNumber) {
-              return
-            }
+  get _internalEvents() {
+    return (0, _pdfjsLib.shadow)(this, "_internalEvents", new Map());
+  }
 
-            if (this._currentScaleValue && isNaN(this._currentScaleValue)) {
-              this._setScale(this._currentScaleValue, true)
-            }
+  get _domEvents() {
+    return (0, _pdfjsLib.shadow)(this, "_domEvents", new Map());
+  }
 
-            this._setCurrentPageNumber(pageNumber, true)
+  get _pageOpenPending() {
+    return (0, _pdfjsLib.shadow)(this, "_pageOpenPending", new Set());
+  }
 
-            this.update()
-          }
+  get _visitedPages() {
+    return (0, _pdfjsLib.shadow)(this, "_visitedPages", new Map());
+  }
 
-          _getPageAdvance (currentPageNumber, previous = false) {
-            if (this.isInPresentationMode) {
-              return 1
-            }
+  async _updateFromSandbox(detail) {
+    const isInPresentationMode = this._pdfViewer.isInPresentationMode || this._pdfViewer.isChangingPresentationMode;
+    const {
+      id,
+      siblings,
+      command,
+      value
+    } = detail;
 
-            switch (this._scrollMode) {
-              case _ui_utils.ScrollMode.WRAPPED: {
-                const {
-                    views
-                  } = this._getVisiblePages(),
-                  pageLayout = new Map()
-
-                for (const {
-                  id,
-                  y,
-                  percent,
-                  widthPercent
-                } of views) {
-                  if (percent === 0 || widthPercent < 100) {
-                    continue
-                  }
-
-                  let yArray = pageLayout.get(y)
-
-                  if (!yArray) {
-                    pageLayout.set(y, yArray || (yArray = []))
-                  }
-
-                  yArray.push(id)
-                }
+    if (!id) {
+      switch (command) {
+        case "clear":
+          console.clear();
+          break;
 
-                for (const yArray of pageLayout.values()) {
-                  const currentIndex = yArray.indexOf(currentPageNumber)
-
-                  if (currentIndex === -1) {
-                    continue
-                  }
-
-                  const numPages = yArray.length
-
-                  if (numPages === 1) {
-                    break
-                  }
-
-                  if (previous) {
-                    for (let i = currentIndex - 1, ii = 0; i >= ii; i--) {
-                      const currentId = yArray[i],
-                        expectedId = yArray[i + 1] - 1
-
-                      if (currentId < expectedId) {
-                        return currentPageNumber - expectedId
-                      }
-                    }
-                  } else {
-                    for (let i = currentIndex + 1, ii = numPages; i < ii; i++) {
-                      const currentId = yArray[i],
-                        expectedId = yArray[i - 1] + 1
-
-                      if (currentId > expectedId) {
-                        return expectedId - currentPageNumber
-                      }
-                    }
-                  }
-
-                  if (previous) {
-                    const firstId = yArray[0]
-
-                    if (firstId < currentPageNumber) {
-                      return currentPageNumber - firstId + 1
-                    }
-                  } else {
-                    const lastId = yArray[numPages - 1]
-
-                    if (lastId > currentPageNumber) {
-                      return lastId - currentPageNumber + 1
-                    }
-                  }
-
-                  break
-                }
+        case "error":
+          console.error(value);
+          break;
 
-                break
-              }
+        case "layout":
+          if (isInPresentationMode) {
+            return;
+          }
 
-              case _ui_utils.ScrollMode.HORIZONTAL: {
-                break
-              }
+          const modes = (0, _ui_utils.apiPageLayoutToViewerModes)(value);
+          this._pdfViewer.spreadMode = modes.spreadMode;
+          break;
 
-              case _ui_utils.ScrollMode.VERTICAL: {
-                if (this._spreadMode === _ui_utils.SpreadMode.NONE) {
-                  break
-                }
+        case "page-num":
+          this._pdfViewer.currentPageNumber = value + 1;
+          break;
 
-                const parity = this._spreadMode - 1
+        case "print":
+          await this._pdfViewer.pagesPromise;
 
-                if (previous && currentPageNumber % 2 !== parity) {
-                  break
-                } else if (!previous && currentPageNumber % 2 === parity) {
-                  break
-                }
+          this._eventBus.dispatch("print", {
+            source: this
+          });
 
-                const {
-                    views
-                  } = this._getVisiblePages(),
-                  expectedId = previous ? currentPageNumber - 1 : currentPageNumber + 1
-
-                for (const {
-                  id,
-                  percent,
-                  widthPercent
-                } of views) {
-                  if (id !== expectedId) {
-                    continue
-                  }
-
-                  if (percent > 0 && widthPercent === 100) {
-                    return 2
-                  }
-
-                  break
-                }
+          break;
 
-                break
-              }
-            }
+        case "println":
+          console.log(value);
+          break;
 
-            return 1
+        case "zoom":
+          if (isInPresentationMode) {
+            return;
           }
 
-          nextPage () {
-            const currentPageNumber = this._currentPageNumber,
-              pagesCount = this.pagesCount
+          this._pdfViewer.currentScaleValue = value;
+          break;
 
-            if (currentPageNumber >= pagesCount) {
-              return false
-            }
+        case "SaveAs":
+          this._eventBus.dispatch("save", {
+            source: this
+          });
 
-            const advance = this._getPageAdvance(currentPageNumber, false) || 1
-            this.currentPageNumber = Math.min(currentPageNumber + advance, pagesCount)
-            return true
-          }
+          break;
 
-          previousPage () {
-            const currentPageNumber = this._currentPageNumber
+        case "FirstPage":
+          this._pdfViewer.currentPageNumber = 1;
+          break;
 
-            if (currentPageNumber <= 1) {
-              return false
-            }
+        case "LastPage":
+          this._pdfViewer.currentPageNumber = this._pdfViewer.pagesCount;
+          break;
 
-            const advance = this._getPageAdvance(currentPageNumber, true) || 1
-            this.currentPageNumber = Math.max(currentPageNumber - advance, 1)
-            return true
-          }
+        case "NextPage":
+          this._pdfViewer.nextPage();
 
-        }
+          break;
 
-        exports.BaseViewer = BaseViewer
+        case "PrevPage":
+          this._pdfViewer.previousPage();
 
-        /***/
-      }),
-      /* 20 */
-      /***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
-
-        Object.defineProperty(exports, '__esModule', ({
-          value: true
-        }))
-        exports.XfaLayerBuilder = exports.DefaultXfaLayerFactory = void 0
-
-        var _pdfjsLib = __w_pdfjs_require__(2)
-
-        class XfaLayerBuilder {
-          constructor ({
-            pageDiv,
-            pdfPage
-          }) {
-            this.pageDiv = pageDiv
-            this.pdfPage = pdfPage
-            this.div = null
-            this._cancelled = false
-          }
+          break;
 
-          render (viewport, intent = 'display') {
-            return this.pdfPage.getXfa().then(xfa => {
-              if (this._cancelled) {
-                return
-              }
+        case "ZoomViewIn":
+          if (isInPresentationMode) {
+            return;
+          }
 
-              const parameters = {
-                viewport: viewport.clone({
-                  dontFlip: true
-                }),
-                div: this.div,
-                xfa,
-                page: this.pdfPage
-              }
+          this._pdfViewer.increaseScale();
 
-              if (this.div) {
-                _pdfjsLib.XfaLayer.update(parameters)
-              } else {
-                this.div = document.createElement('div')
-                this.pageDiv.appendChild(this.div)
-                parameters.div = this.div
+          break;
 
-                _pdfjsLib.XfaLayer.render(parameters)
-              }
-            })
+        case "ZoomViewOut":
+          if (isInPresentationMode) {
+            return;
           }
 
-          cancel () {
-            this._cancelled = true
-          }
+          this._pdfViewer.decreaseScale();
 
-          hide () {
-            if (!this.div) {
-              return
-            }
+          break;
+      }
 
-            this.div.hidden = true
-          }
+      return;
+    }
 
-        }
+    if (isInPresentationMode) {
+      if (detail.focus) {
+        return;
+      }
+    }
 
-        exports.XfaLayerBuilder = XfaLayerBuilder
+    delete detail.id;
+    delete detail.siblings;
+    const ids = siblings ? [id, ...siblings] : [id];
 
-        class DefaultXfaLayerFactory {
-          createXfaLayerBuilder (pageDiv, pdfPage) {
-            return new XfaLayerBuilder({
-              pageDiv,
-              pdfPage
-            })
-          }
+    for (const elementId of ids) {
+      const element = document.getElementById(elementId);
 
-        }
+      if (element) {
+        element.dispatchEvent(new CustomEvent("updatefromsandbox", {
+          detail
+        }));
+      } else {
+        this._pdfDocument?.annotationStorage.setValue(elementId, detail);
+      }
+    }
+  }
 
-        exports.DefaultXfaLayerFactory = DefaultXfaLayerFactory
+  async _dispatchPageOpen(pageNumber, initialize = false) {
+    const pdfDocument = this._pdfDocument,
+          visitedPages = this._visitedPages;
 
-        /***/
-      }),
-      /* 21 */
-      /***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+    if (initialize) {
+      this._closeCapability = (0, _pdfjsLib.createPromiseCapability)();
+    }
 
-        Object.defineProperty(exports, '__esModule', ({
-          value: true
-        }))
-        exports.PDFViewer = void 0
+    if (!this._closeCapability) {
+      return;
+    }
 
-        var _ui_utils = __w_pdfjs_require__(5)
+    const pageView = this._pdfViewer.getPageView(pageNumber - 1);
 
-        var _base_viewer = __w_pdfjs_require__(19)
+    if (pageView?.renderingState !== _ui_utils.RenderingStates.FINISHED) {
+      this._pageOpenPending.add(pageNumber);
 
-        var _pdfjsLib = __w_pdfjs_require__(2)
+      return;
+    }
 
-        class PDFViewer extends _base_viewer.BaseViewer {
-          get _viewerElement () {
-            return (0, _pdfjsLib.shadow)(this, '_viewerElement', this.viewer)
-          }
+    this._pageOpenPending.delete(pageNumber);
 
-          _scrollIntoView ({
-            pageDiv,
-            pageSpot = null,
-            pageNumber = null
-          }) {
-            if (!pageSpot && !this.isInPresentationMode) {
-              const left = pageDiv.offsetLeft + pageDiv.clientLeft
-              const right = left + pageDiv.clientWidth
-              const {
-                scrollLeft,
-                clientWidth
-              } = this.container
-
-              if (this._isScrollModeHorizontal || left < scrollLeft || right > scrollLeft + clientWidth) {
-                pageSpot = {
-                  left: 0,
-                  top: 0
-                }
-              }
-            }
+    const actionsPromise = (async () => {
+      const actions = await (!visitedPages.has(pageNumber) ? pageView.pdfPage?.getJSActions() : null);
 
-            super._scrollIntoView({
-              pageDiv,
-              pageSpot,
-              pageNumber
-            })
-          }
+      if (pdfDocument !== this._pdfDocument) {
+        return;
+      }
 
-          _getVisiblePages () {
-            if (this.isInPresentationMode) {
-              return this._getCurrentVisiblePage()
-            }
+      await this._scripting?.dispatchEventInSandbox({
+        id: "page",
+        name: "PageOpen",
+        pageNumber,
+        actions
+      });
+    })();
 
-            return super._getVisiblePages()
-          }
+    visitedPages.set(pageNumber, actionsPromise);
+  }
 
-          _updateHelper (visiblePages) {
-            if (this.isInPresentationMode) {
-              return
-            }
+  async _dispatchPageClose(pageNumber) {
+    const pdfDocument = this._pdfDocument,
+          visitedPages = this._visitedPages;
 
-            let currentId = this._currentPageNumber
-            let stillFullyVisible = false
+    if (!this._closeCapability) {
+      return;
+    }
 
-            for (const page of visiblePages) {
-              if (page.percent < 100) {
-                break
-              }
+    if (this._pageOpenPending.has(pageNumber)) {
+      return;
+    }
 
-              if (page.id === currentId && this._scrollMode === _ui_utils.ScrollMode.VERTICAL && this._spreadMode === _ui_utils.SpreadMode.NONE) {
-                stillFullyVisible = true
-                break
-              }
-            }
+    const actionsPromise = visitedPages.get(pageNumber);
 
-            if (!stillFullyVisible) {
-              currentId = visiblePages[0].id
-            }
+    if (!actionsPromise) {
+      return;
+    }
 
-            this._setCurrentPageNumber(currentId)
-          }
+    visitedPages.set(pageNumber, null);
+    await actionsPromise;
 
-        }
+    if (pdfDocument !== this._pdfDocument) {
+      return;
+    }
 
-        exports.PDFViewer = PDFViewer
-
-        /***/
-      })
-      /******/])
-    /************************************************************************/
-    /******/ 	// The module cache
-    /******/
-    var __webpack_module_cache__ = {}
-    /******/
-    /******/ 	// The require function
-    /******/
-    function __w_pdfjs_require__ (moduleId) {
-      /******/ 		// Check if module is in cache
-      /******/
-      var cachedModule = __webpack_module_cache__[moduleId]
-      /******/
-      if (cachedModule !== undefined) {
-        /******/
-        return cachedModule.exports
-        /******/
-      }
-      /******/ 		// Create a new module (and put it into the cache)
-      /******/
-      var module = __webpack_module_cache__[moduleId] = {
-        /******/ 			// no module.id needed
-        /******/ 			// no module.loaded needed
-        /******/      exports: {}
-        /******/
-      }
-      /******/
-      /******/ 		// Execute the module function
-      /******/
-      __webpack_modules__[moduleId](module, module.exports, __w_pdfjs_require__)
-      /******/
-      /******/ 		// Return the exports of the module
-      /******/
-      return module.exports
-      /******/
-    }
-
-    /******/
-    /************************************************************************/
-    var __webpack_exports__ = {};
-// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
-    (() => {
-      var exports = __webpack_exports__
-
-      Object.defineProperty(exports, '__esModule', ({
-        value: true
-      }))
-      Object.defineProperty(exports, 'AnnotationLayerBuilder', ({
-        enumerable: true,
-        get: function () {
-          return _annotation_layer_builder.AnnotationLayerBuilder
-        }
-      }))
-      Object.defineProperty(exports, 'DefaultAnnotationLayerFactory', ({
-        enumerable: true,
-        get: function () {
-          return _annotation_layer_builder.DefaultAnnotationLayerFactory
-        }
-      }))
-      Object.defineProperty(exports, 'DefaultTextLayerFactory', ({
-        enumerable: true,
-        get: function () {
-          return _text_layer_builder.DefaultTextLayerFactory
-        }
-      }))
-      Object.defineProperty(exports, 'TextLayerBuilder', ({
-        enumerable: true,
-        get: function () {
-          return _text_layer_builder.TextLayerBuilder
-        }
-      }))
-      Object.defineProperty(exports, 'EventBus', ({
-        enumerable: true,
-        get: function () {
-          return _ui_utils.EventBus
-        }
-      }))
-      Object.defineProperty(exports, 'ProgressBar', ({
-        enumerable: true,
-        get: function () {
-          return _ui_utils.ProgressBar
-        }
-      }))
-      Object.defineProperty(exports, 'PDFLinkService', ({
-        enumerable: true,
-        get: function () {
-          return _pdf_link_service.PDFLinkService
-        }
-      }))
-      Object.defineProperty(exports, 'SimpleLinkService', ({
-        enumerable: true,
-        get: function () {
-          return _pdf_link_service.SimpleLinkService
-        }
-      }))
-      Object.defineProperty(exports, 'DownloadManager', ({
-        enumerable: true,
-        get: function () {
-          return _download_manager.DownloadManager
-        }
-      }))
-      Object.defineProperty(exports, 'GenericL10n', ({
-        enumerable: true,
-        get: function () {
-          return _genericl10n.GenericL10n
-        }
-      }))
-      Object.defineProperty(exports, 'NullL10n', ({
-        enumerable: true,
-        get: function () {
-          return _l10n_utils.NullL10n
-        }
-      }))
-      Object.defineProperty(exports, 'PDFFindController', ({
-        enumerable: true,
-        get: function () {
-          return _pdf_find_controller.PDFFindController
-        }
-      }))
-      Object.defineProperty(exports, 'PDFHistory', ({
-        enumerable: true,
-        get: function () {
-          return _pdf_history.PDFHistory
-        }
-      }))
-      Object.defineProperty(exports, 'PDFPageView', ({
-        enumerable: true,
-        get: function () {
-          return _pdf_page_view.PDFPageView
-        }
-      }))
-      Object.defineProperty(exports, 'PDFScriptingManager', ({
-        enumerable: true,
-        get: function () {
-          return _pdf_scripting_manager.PDFScriptingManager
-        }
-      }))
-      Object.defineProperty(exports, 'PDFSinglePageViewer', ({
-        enumerable: true,
-        get: function () {
-          return _pdf_single_page_viewer.PDFSinglePageViewer
-        }
-      }))
-      Object.defineProperty(exports, 'PDFViewer', ({
-        enumerable: true,
-        get: function () {
-          return _pdf_viewer.PDFViewer
-        }
-      }))
+    await this._scripting?.dispatchEventInSandbox({
+      id: "page",
+      name: "PageClose",
+      pageNumber
+    });
+  }
 
-      var _annotation_layer_builder = __w_pdfjs_require__(1)
+  async _getDocProperties() {
+    if (this._docPropertiesLookup) {
+      return this._docPropertiesLookup(this._pdfDocument);
+    }
 
-      var _text_layer_builder = __w_pdfjs_require__(6)
+    const {
+      docPropertiesLookup
+    } = __w_pdfjs_require__(24);
 
-      var _ui_utils = __w_pdfjs_require__(5)
+    return docPropertiesLookup(this._pdfDocument);
+  }
 
-      var _pdf_link_service = __w_pdfjs_require__(4)
+  _createScripting() {
+    this._destroyCapability = (0, _pdfjsLib.createPromiseCapability)();
 
-      var _download_manager = __w_pdfjs_require__(7)
+    if (this._scripting) {
+      throw new Error("_createScripting: Scripting already exists.");
+    }
 
-      var _genericl10n = __w_pdfjs_require__(9)
+    if (this._scriptingFactory) {
+      return this._scriptingFactory.createScripting({
+        sandboxBundleSrc: this._sandboxBundleSrc
+      });
+    }
 
-      var _l10n_utils = __w_pdfjs_require__(3)
+    const {
+      GenericScripting
+    } = __w_pdfjs_require__(24);
 
-      var _pdf_find_controller = __w_pdfjs_require__(11)
+    return new GenericScripting(this._sandboxBundleSrc);
+  }
 
-      var _pdf_history = __w_pdfjs_require__(13)
+  async _destroyScripting() {
+    if (!this._scripting) {
+      this._pdfDocument = null;
+      this._destroyCapability?.resolve();
+      return;
+    }
 
-      var _pdf_page_view = __w_pdfjs_require__(14)
+    if (this._closeCapability) {
+      await Promise.race([this._closeCapability.promise, new Promise(resolve => {
+        setTimeout(resolve, 1000);
+      })]).catch(reason => {});
+      this._closeCapability = null;
+    }
 
-      var _pdf_scripting_manager = __w_pdfjs_require__(16)
+    this._pdfDocument = null;
 
-      var _pdf_single_page_viewer = __w_pdfjs_require__(18)
+    try {
+      await this._scripting.destroySandbox();
+    } catch (ex) {}
 
-      var _pdf_viewer = __w_pdfjs_require__(21)
+    for (const [name, listener] of this._internalEvents) {
+      this._eventBus._off(name, listener);
+    }
 
-      const pdfjsVersion = '2.8.335'
-      const pdfjsBuild = '228adbf67'
-    })()
+    this._internalEvents.clear();
 
-    /******/
-    return __webpack_exports__
-    /******/
-  })()
+    for (const [name, listener] of this._domEvents) {
+      window.removeEventListener(name, listener, true);
+    }
 
-})
+    this._domEvents.clear();
+
+    this._pageOpenPending.clear();
+
+    this._visitedPages.clear();
+
+    this._scripting = null;
+    delete this._mouseState.isDown;
+    this._ready = false;
+    this._destroyCapability?.resolve();
+  }
+
+}
+
+exports.PDFScriptingManager = PDFScriptingManager;
+
+/***/ }),
+/* 24 */
+/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.GenericScripting = void 0;
+exports.docPropertiesLookup = docPropertiesLookup;
+
+var _pdfjsLib = __w_pdfjs_require__(3);
+
+async function docPropertiesLookup(pdfDocument) {
+  const url = "",
+        baseUrl = url.split("#")[0];
+  let {
+    info,
+    metadata,
+    contentDispositionFilename,
+    contentLength
+  } = await pdfDocument.getMetadata();
+
+  if (!contentLength) {
+    const {
+      length
+    } = await pdfDocument.getDownloadInfo();
+    contentLength = length;
+  }
+
+  return { ...info,
+    baseURL: baseUrl,
+    filesize: contentLength,
+    filename: contentDispositionFilename || (0, _pdfjsLib.getPdfFilenameFromUrl)(url),
+    metadata: metadata?.getRaw(),
+    authors: metadata?.get("dc:creator"),
+    numPages: pdfDocument.numPages,
+    URL: url
+  };
+}
+
+class GenericScripting {
+  constructor(sandboxBundleSrc) {
+    this._ready = (0, _pdfjsLib.loadScript)(sandboxBundleSrc, true).then(() => {
+      return window.pdfjsSandbox.QuickJSSandbox();
+    });
+  }
+
+  async createSandbox(data) {
+    const sandbox = await this._ready;
+    sandbox.create(data);
+  }
+
+  async dispatchEventInSandbox(event) {
+    const sandbox = await this._ready;
+    setTimeout(() => sandbox.dispatchEvent(event), 0);
+  }
+
+  async destroySandbox() {
+    const sandbox = await this._ready;
+    sandbox.nukeSandbox();
+  }
+
+}
+
+exports.GenericScripting = GenericScripting;
+
+/***/ })
+/******/ 	]);
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __w_pdfjs_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __w_pdfjs_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
+(() => {
+var exports = __webpack_exports__;
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+Object.defineProperty(exports, "AnnotationLayerBuilder", ({
+  enumerable: true,
+  get: function () {
+    return _annotation_layer_builder.AnnotationLayerBuilder;
+  }
+}));
+Object.defineProperty(exports, "DefaultAnnotationLayerFactory", ({
+  enumerable: true,
+  get: function () {
+    return _default_factory.DefaultAnnotationLayerFactory;
+  }
+}));
+Object.defineProperty(exports, "DefaultStructTreeLayerFactory", ({
+  enumerable: true,
+  get: function () {
+    return _default_factory.DefaultStructTreeLayerFactory;
+  }
+}));
+Object.defineProperty(exports, "DefaultTextLayerFactory", ({
+  enumerable: true,
+  get: function () {
+    return _default_factory.DefaultTextLayerFactory;
+  }
+}));
+Object.defineProperty(exports, "DefaultXfaLayerFactory", ({
+  enumerable: true,
+  get: function () {
+    return _default_factory.DefaultXfaLayerFactory;
+  }
+}));
+Object.defineProperty(exports, "DownloadManager", ({
+  enumerable: true,
+  get: function () {
+    return _download_manager.DownloadManager;
+  }
+}));
+Object.defineProperty(exports, "EventBus", ({
+  enumerable: true,
+  get: function () {
+    return _event_utils.EventBus;
+  }
+}));
+Object.defineProperty(exports, "GenericL10n", ({
+  enumerable: true,
+  get: function () {
+    return _genericl10n.GenericL10n;
+  }
+}));
+Object.defineProperty(exports, "LinkTarget", ({
+  enumerable: true,
+  get: function () {
+    return _pdf_link_service.LinkTarget;
+  }
+}));
+Object.defineProperty(exports, "NullL10n", ({
+  enumerable: true,
+  get: function () {
+    return _l10n_utils.NullL10n;
+  }
+}));
+Object.defineProperty(exports, "PDFFindController", ({
+  enumerable: true,
+  get: function () {
+    return _pdf_find_controller.PDFFindController;
+  }
+}));
+Object.defineProperty(exports, "PDFHistory", ({
+  enumerable: true,
+  get: function () {
+    return _pdf_history.PDFHistory;
+  }
+}));
+Object.defineProperty(exports, "PDFLinkService", ({
+  enumerable: true,
+  get: function () {
+    return _pdf_link_service.PDFLinkService;
+  }
+}));
+Object.defineProperty(exports, "PDFPageView", ({
+  enumerable: true,
+  get: function () {
+    return _pdf_page_view.PDFPageView;
+  }
+}));
+Object.defineProperty(exports, "PDFScriptingManager", ({
+  enumerable: true,
+  get: function () {
+    return _pdf_scripting_manager.PDFScriptingManager;
+  }
+}));
+Object.defineProperty(exports, "PDFSinglePageViewer", ({
+  enumerable: true,
+  get: function () {
+    return _pdf_viewer.PDFSinglePageViewer;
+  }
+}));
+Object.defineProperty(exports, "PDFViewer", ({
+  enumerable: true,
+  get: function () {
+    return _pdf_viewer.PDFViewer;
+  }
+}));
+Object.defineProperty(exports, "ProgressBar", ({
+  enumerable: true,
+  get: function () {
+    return _ui_utils.ProgressBar;
+  }
+}));
+Object.defineProperty(exports, "SimpleLinkService", ({
+  enumerable: true,
+  get: function () {
+    return _pdf_link_service.SimpleLinkService;
+  }
+}));
+Object.defineProperty(exports, "StructTreeLayerBuilder", ({
+  enumerable: true,
+  get: function () {
+    return _struct_tree_layer_builder.StructTreeLayerBuilder;
+  }
+}));
+Object.defineProperty(exports, "TextLayerBuilder", ({
+  enumerable: true,
+  get: function () {
+    return _text_layer_builder.TextLayerBuilder;
+  }
+}));
+Object.defineProperty(exports, "XfaLayerBuilder", ({
+  enumerable: true,
+  get: function () {
+    return _xfa_layer_builder.XfaLayerBuilder;
+  }
+}));
+Object.defineProperty(exports, "parseQueryString", ({
+  enumerable: true,
+  get: function () {
+    return _ui_utils.parseQueryString;
+  }
+}));
+
+var _default_factory = __w_pdfjs_require__(1);
+
+var _pdf_link_service = __w_pdfjs_require__(5);
+
+var _ui_utils = __w_pdfjs_require__(6);
+
+var _pdf_viewer = __w_pdfjs_require__(10);
+
+var _annotation_layer_builder = __w_pdfjs_require__(2);
+
+var _download_manager = __w_pdfjs_require__(16);
+
+var _event_utils = __w_pdfjs_require__(17);
+
+var _genericl10n = __w_pdfjs_require__(18);
+
+var _l10n_utils = __w_pdfjs_require__(4);
+
+var _pdf_find_controller = __w_pdfjs_require__(20);
+
+var _pdf_history = __w_pdfjs_require__(22);
+
+var _pdf_page_view = __w_pdfjs_require__(12);
+
+var _pdf_scripting_manager = __w_pdfjs_require__(23);
+
+var _struct_tree_layer_builder = __w_pdfjs_require__(7);
+
+var _text_layer_builder = __w_pdfjs_require__(8);
+
+var _xfa_layer_builder = __w_pdfjs_require__(9);
+
+const pdfjsVersion = '2.14.305';
+const pdfjsBuild = 'eaaa8b4ad';
+})();
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});
 //# sourceMappingURL=pdf_viewer.js.map

src/main/frontend/extensions/pdf/_viewer.css

@@ -15,6 +15,7 @@
 
 .textLayer {
   position: absolute;
+  text-align: initial;
   left: 0;
   top: 0;
   right: 0;
@@ -22,9 +23,14 @@
   overflow: hidden;
   opacity: 0.2;
   line-height: 1;
+  -webkit-text-size-adjust: none;
+     -moz-text-size-adjust: none;
+          text-size-adjust: none;
+  forced-color-adjust: none;
 }
 
-.textLayer > span {
+.textLayer span,
+.textLayer br {
   color: transparent;
   position: absolute;
   white-space: pre;
@@ -32,6 +38,13 @@
   transform-origin: 0% 0%;
 }
 
+/* Only necessary in Google Chrome, see issue 14205, and most unfortunately
+ * the problem doesn't show up in "text" reference tests. */
+.textLayer span.markedContent {
+  top: 0;
+  height: 0;
+}
+
 .textLayer .highlight {
   margin: -1px;
   padding: 1px;
@@ -39,6 +52,10 @@
   border-radius: 4px;
 }
 
+.textLayer .highlight.appended {
+  position: initial;
+}
+
 .textLayer .highlight.begin {
   border-radius: 4px 0 0 4px;
 }
@@ -63,6 +80,14 @@
   background: rgba(0, 0, 255, 1);
 }
 
+/* Avoids https://github.com/mozilla/pdf.js/issues/13840 in Chrome */
+.textLayer br::-moz-selection {
+  background: transparent;
+}
+.textLayer br::selection {
+  background: transparent;
+}
+
 .textLayer .endOfContent {
   display: block;
   position: absolute;
@@ -73,8 +98,8 @@
   z-index: -1;
   cursor: default;
   -webkit-user-select: none;
-  -moz-user-select: none;
-  user-select: none;
+     -moz-user-select: none;
+          user-select: none;
 }
 
 .textLayer .endOfContent.active {
@@ -82,6 +107,10 @@
 }
 
 
+:root {
+  --annotation-unfocused-field-background: url("data:image/svg+xml;charset=UTF-8,<svg width='1px' height='1px' xmlns='http://www.w3.org/2000/svg'><rect width='100%' height='100%' style='fill:rgba(0, 54, 255, 0.13);'/></svg>");
+}
+
 .annotationLayer section {
   position: absolute;
   text-align: initial;
@@ -97,6 +126,13 @@
   height: 100%;
 }
 
+.annotationLayer .buttonWidgetAnnotation.pushButton > canvas {
+  position: relative;
+  top: 0;
+  left: 0;
+  z-index: -1;
+}
+
 .annotationLayer .linkAnnotation > a:hover,
 .annotationLayer .buttonWidgetAnnotation.pushButton > a:hover {
   opacity: 0.2;
@@ -114,7 +150,7 @@
 .annotationLayer .choiceWidgetAnnotation select,
 .annotationLayer .buttonWidgetAnnotation.checkBox input,
 .annotationLayer .buttonWidgetAnnotation.radioButton input {
-  background-color: rgba(0, 54, 255, 0.13);
+  background-image: var(--annotation-unfocused-field-background);
   border: 1px solid transparent;
   box-sizing: border-box;
   font-size: 9px;
@@ -164,6 +200,16 @@
   border: 1px solid transparent;
 }
 
+.annotationLayer .textWidgetAnnotation input :focus,
+.annotationLayer .textWidgetAnnotation textarea :focus,
+.annotationLayer .choiceWidgetAnnotation select :focus,
+.annotationLayer .buttonWidgetAnnotation.checkBox :focus,
+.annotationLayer .buttonWidgetAnnotation.radioButton :focus {
+  background-image: none;
+  background-color: transparent;
+  outline: auto;
+}
+
 .annotationLayer .buttonWidgetAnnotation.checkBox input:checked:before,
 .annotationLayer .buttonWidgetAnnotation.checkBox input:checked:after,
 .annotationLayer .buttonWidgetAnnotation.radioButton input:checked:before {
@@ -209,14 +255,14 @@
    * area, causing horizontal scrolling. We avoid this by extending the width
    * when the element has focus and revert this when it loses focus.
    */
-  width: 115%;
+  width: 103%;
 }
 
 .annotationLayer .buttonWidgetAnnotation.checkBox input,
 .annotationLayer .buttonWidgetAnnotation.radioButton input {
   -webkit-appearance: none;
-  -moz-appearance: none;
-  appearance: none;
+     -moz-appearance: none;
+          appearance: none;
   padding: 0;
 }
 
@@ -249,17 +295,21 @@
   display: inline-block;
 }
 
-.annotationLayer .popup span {
+.annotationLayer .popupDate {
   display: inline-block;
   margin-left: 5px;
 }
 
-.annotationLayer .popup p {
+.annotationLayer .popupContent {
   border-top: 1px solid rgba(51, 51, 51, 1);
   margin-top: 2px;
   padding-top: 2px;
 }
 
+.annotationLayer .richText > * {
+  white-space: pre-wrap;
+}
+
 .annotationLayer .highlightAnnotation,
 .annotationLayer .underlineAnnotation,
 .annotationLayer .squigglyAnnotation,
@@ -277,44 +327,108 @@
   cursor: pointer;
 }
 
-* /* Copyright 2021 Mozilla Foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+
+:root {
+  --xfa-unfocused-field-background: url("data:image/svg+xml;charset=UTF-8,<svg width='1px' height='1px' xmlns='http://www.w3.org/2000/svg'><rect width='100%' height='100%' style='fill:rgba(0, 54, 255, 0.13);'/></svg>");
+}
+
+.xfaLayer .highlight {
+  margin: -1px;
+  padding: 1px;
+  background-color: rgba(239, 203, 237, 1);
+  border-radius: 4px;
+}
+
+.xfaLayer .highlight.appended {
+  position: initial;
+}
+
+.xfaLayer .highlight.begin {
+  border-radius: 4px 0 0 4px;
+}
+
+.xfaLayer .highlight.end {
+  border-radius: 0 4px 4px 0;
+}
+
+.xfaLayer .highlight.middle {
+  border-radius: 0;
+}
+
+.xfaLayer .highlight.selected {
+  background-color: rgba(203, 223, 203, 1);
+}
+
+.xfaLayer ::-moz-selection {
+  background: rgba(0, 0, 255, 1);
+}
+
+.xfaLayer ::selection {
+  background: rgba(0, 0, 255, 1);
+}
+
+.xfaPage {
+  overflow: hidden;
+  position: relative;
+}
+
+.xfaContentarea {
+  position: absolute;
+}
+
+.xfaPrintOnly {
+  display: none;
+}
+
 .xfaLayer {
   position: absolute;
+  text-align: initial;
   top: 0;
   left: 0;
-  z-index: 200;
   transform-origin: 0 0;
+  line-height: 1.2;
 }
 
 .xfaLayer * {
   color: inherit;
   font: inherit;
-  -webkit-font-kerning: inherit;
+  font-style: inherit;
+  font-weight: inherit;
   font-kerning: inherit;
-  letter-spacing: inherit;
+  letter-spacing: -0.01px;
   text-align: inherit;
   text-decoration: inherit;
-  vertical-align: inherit;
   box-sizing: border-box;
+  background-color: transparent;
+  padding: 0;
+  margin: 0;
+  pointer-events: auto;
+  line-height: inherit;
+}
+
+.xfaLayer div {
+  pointer-events: none;
+}
+
+.xfaLayer svg {
+  pointer-events: none;
+}
+
+.xfaLayer svg * {
+  pointer-events: none;
+}
+
+.xfaLayer a {
+  color: blue;
+}
+
+.xfaRich li {
+  margin-left: 3em;
 }
 
 .xfaFont {
   color: black;
   font-weight: normal;
-  -webkit-font-kerning: none;
   font-kerning: none;
   font-size: 10px;
   font-style: normal;
@@ -323,130 +437,192 @@
   vertical-align: 0;
 }
 
-.xfaDraw {
-  z-index: 200;
+.xfaCaption {
+  overflow: hidden;
+  flex: 0 0 auto;
 }
 
-.xfaExclgroup {
-  z-index: 300;
+.xfaCaptionForCheckButton {
+  overflow: hidden;
+  flex: 1 1 auto;
 }
 
-.xfaField {
-  z-index: 300;
+.xfaLabel {
+  height: 100%;
+  width: 100%;
 }
 
-.xfaSubform {
-  z-index: 100;
+.xfaLeft {
+  display: flex;
+  flex-direction: row;
+  align-items: center;
 }
 
-.xfaLabel {
+.xfaRight {
   display: flex;
-  flex-direction: row;
+  flex-direction: row-reverse;
   align-items: center;
+}
+
+.xfaLeft > .xfaCaption,
+.xfaLeft > .xfaCaptionForCheckButton,
+.xfaRight > .xfaCaption,
+.xfaRight > .xfaCaptionForCheckButton {
+  max-height: 100%;
+}
+
+.xfaTop {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+}
+
+.xfaBottom {
+  display: flex;
+  flex-direction: column-reverse;
+  align-items: flex-start;
+}
+
+.xfaTop > .xfaCaption,
+.xfaTop > .xfaCaptionForCheckButton,
+.xfaBottom > .xfaCaption,
+.xfaBottom > .xfaCaptionForCheckButton {
+  width: 100%;
+}
+
+.xfaBorder {
+  background-color: transparent;
+  position: absolute;
+  pointer-events: none;
+}
+
+.xfaWrapped {
   width: 100%;
   height: 100%;
 }
 
-.xfaCaption {
-  flex: 1 1 auto;
+.xfaTextfield:focus,
+.xfaSelect:focus {
+  background-image: none;
+  background-color: transparent;
+  outline: auto;
+  outline-offset: -1px;
+}
+
+.xfaCheckbox:focus,
+.xfaRadio:focus {
+  outline: auto;
 }
 
 .xfaTextfield,
 .xfaSelect {
-  width: 100%;
   height: 100%;
+  width: 100%;
   flex: 1 1 auto;
   border: none;
+  resize: none;
+  background-image: var(--xfa-unfocused-field-background);
 }
 
-.xfaLabel > input[type="checkbox"] {
-  /* Use this trick to make the checkbox invisible but
-       but still focusable. */
-  position: absolute;
-  left: -99999px;
-}
-
-.xfaLabel > input[type="checkbox"]:focus + .xfaCheckboxMark {
-  box-shadow: 0 0 5px rgba(0, 0, 0, 0.7);
+.xfaTop > .xfaTextfield,
+.xfaTop > .xfaSelect,
+.xfaBottom > .xfaTextfield,
+.xfaBottom > .xfaSelect {
+  flex: 0 1 auto;
 }
 
-.xfaCheckboxMark {
+.xfaButton {
   cursor: pointer;
-  flex: 0 0 auto;
-  border-style: solid;
-  border-width: 2px;
-  border-color: #8f8f9d;
-  font-size: 10px;
-  line-height: 10px;
-  width: 10px;
-  height: 10px;
+  width: 100%;
+  height: 100%;
+  border: none;
   text-align: center;
-  vertical-align: middle;
-  display: flex;
-  flex-direction: row;
-  align-items: center;
 }
 
-.xfaCheckbox:checked + .xfaCheckboxMark::after {
-  content: attr(mark);
+.xfaLink {
+  width: 100%;
+  height: 100%;
+  position: absolute;
+  top: 0;
+  left: 0;
 }
 
-.xfaButton {
-  cursor: pointer;
+.xfaCheckbox,
+.xfaRadio {
   width: 100%;
   height: 100%;
+  flex: 0 0 auto;
   border: none;
-  text-align: center;
 }
 
-.xfaButton:hover {
-  background: Highlight;
+.xfaRich {
+  white-space: pre-wrap;
+  width: 100%;
+  height: 100%;
+}
+
+.xfaImage {
+  -o-object-position: left top;
+     object-position: left top;
+  -o-object-fit: contain;
+     object-fit: contain;
+  width: 100%;
+  height: 100%;
 }
 
 .xfaLrTb,
 .xfaRlTb,
-.xfaTb,
-.xfaPosition {
-  display: block;
+.xfaTb {
+  display: flex;
+  flex-direction: column;
+  align-items: stretch;
 }
 
-.xfaPosition {
-  position: relative;
+.xfaLr {
+  display: flex;
+  flex-direction: row;
+  align-items: stretch;
 }
 
-.xfaValignMiddle {
+.xfaRl {
   display: flex;
-  align-items: center;
+  flex-direction: row-reverse;
+  align-items: stretch;
 }
 
-.xfaLrTb > div {
-  display: inline;
-  float: left;
+.xfaTb > div {
+  justify-content: left;
 }
 
-.xfaRlTb > div {
-  display: inline;
-  float: right;
+.xfaPosition {
+  position: relative;
+}
+
+.xfaArea {
+  position: relative;
+}
+
+.xfaValignMiddle {
+  display: flex;
+  align-items: center;
 }
 
 .xfaTable {
   display: flex;
   flex-direction: column;
+  align-items: stretch;
 }
 
 .xfaTable .xfaRow {
   display: flex;
   flex-direction: row;
-  flex: 1 1 auto;
-}
-
-.xfaTable .xfaRow > div {
-  flex: 1 1 auto;
+  align-items: stretch;
 }
 
 .xfaTable .xfaRlRow {
   display: flex;
   flex-direction: row-reverse;
+  align-items: stretch;
   flex: 1;
 }
 
@@ -454,6 +630,52 @@
   flex: 1;
 }
 
+.xfaNonInteractive input,
+.xfaNonInteractive textarea,
+.xfaDisabled input,
+.xfaDisabled textarea,
+.xfaReadOnly input,
+.xfaReadOnly textarea {
+  background: initial;
+}
+
+@media print {
+  .xfaTextfield,
+  .xfaSelect {
+    background: transparent;
+  }
+
+  .xfaSelect {
+    -webkit-appearance: none;
+       -moz-appearance: none;
+            appearance: none;
+    text-indent: 1px;
+    text-overflow: "";
+  }
+}
+
+:root {
+  --viewer-container-height: 0;
+  --pdfViewer-padding-bottom: 0;
+  --page-margin: 1px auto -8px;
+  --page-border: 9px solid transparent;
+  --spreadHorizontalWrapped-margin-LR: -3.5px;
+  --zoom-factor: 1;
+}
+
+@media screen and (forced-colors: active) {
+  :root {
+    --pdfViewer-padding-bottom: 9px;
+    --page-margin: 9px auto 0;
+    --page-border: none;
+    --spreadHorizontalWrapped-margin-LR: 4.5px;
+  }
+}
+
+.pdfViewer {
+  padding-bottom: var(--pdfViewer-padding-bottom);
+}
+
 .pdfViewer .canvasWrapper {
   overflow: hidden;
 }
@@ -462,14 +684,22 @@
   direction: ltr;
   width: 816px;
   height: 1056px;
-  margin: 1px auto -8px;
+  margin: var(--page-margin);
   position: relative;
   overflow: visible;
-  border: 9px solid transparent;
+  border: var(--page-border);
   background-clip: content-box;
+  -o-border-image: url(images/shadow.png) 9 9 repeat;
+     border-image: url(images/shadow.png) 9 9 repeat;
   background-color: rgba(255, 255, 255, 1);
 }
 
+.pdfViewer .dummyPage {
+  position: relative;
+  width: 0;
+  height: var(--viewer-container-height);
+}
+
 .pdfViewer.removePageBorders .page {
   margin: 0 auto 10px;
   border: none;
@@ -505,6 +735,7 @@
 }
 
 .spread .page,
+.spread .dummyPage,
 .pdfViewer.scrollHorizontal .page,
 .pdfViewer.scrollWrapped .page,
 .pdfViewer.scrollHorizontal .spread,
@@ -516,8 +747,8 @@
 .spread .page,
 .pdfViewer.scrollHorizontal .page,
 .pdfViewer.scrollWrapped .page {
-  margin-left: -3.5px;
-  margin-right: -3.5px;
+  margin-left: var(--spreadHorizontalWrapped-margin-LR);
+  margin-right: var(--spreadHorizontalWrapped-margin-LR);
 }
 
 .pdfViewer.removePageBorders .spread .page,
@@ -543,35 +774,28 @@
   top: 0;
   right: 0;
   bottom: 0;
+  background: url("images/loading-icon.gif") center no-repeat;
 }
-
-.pdfPresentationMode .pdfViewer {
-  margin-left: 0;
-  margin-right: 0;
-}
-
-.pdfPresentationMode .pdfViewer .page,
-.pdfPresentationMode .pdfViewer .spread {
-  display: block;
+.pdfViewer .page .loadingIcon.notVisible {
+  background: none;
 }
 
-.pdfPresentationMode .pdfViewer .page,
-.pdfPresentationMode .pdfViewer.removePageBorders .page {
-  margin-left: auto;
-  margin-right: auto;
+.pdfViewer.enablePermissions .textLayer span {
+  -webkit-user-select: none !important;
+     -moz-user-select: none !important;
+          user-select: none !important;
+  cursor: not-allowed;
 }
 
-.pdfPresentationMode:-webkit-full-screen .pdfViewer .page {
-  margin-bottom: 100%;
-  border: 0;
+.pdfPresentationMode .pdfViewer {
+  padding-bottom: 0;
 }
 
-.pdfPresentationMode:-moz-full-screen .pdfViewer .page {
-  margin-bottom: 100%;
-  border: 0;
+.pdfPresentationMode .spread {
+  margin: 0;
 }
 
-.pdfPresentationMode:fullscreen .pdfViewer .page {
-  margin-bottom: 100%;
-  border: 0;
+.pdfPresentationMode .pdfViewer .page {
+  margin: 0 auto;
+  border: 2px solid transparent;
 }

src/main/frontend/extensions/pdf/highlights.cljs

@@ -51,6 +51,7 @@
   nil)
 
 (rum/defc pdf-resizer
+  "Watches for changes in the pdf container's width and adjusts the viewer."
   [^js viewer]
   (let [el-ref (rum/use-ref nil)
         adjust-main-size!
@@ -87,8 +88,9 @@
     [:span.extensions__pdf-resizer {:ref el-ref}]))
 
 (rum/defc pdf-highlights-ctx-menu
+  "The contextual menu which appears over a text selection and allows e.g. creating a highlight."
   [^js viewer
-   {:keys [highlight point ^js range]}
+   {:keys [highlight point ^js selection]}
    {:keys [clear-ctx-tip! add-hl! upd-hl! del-hl!]}]
 
   (rum/use-effect!
@@ -120,7 +122,7 @@
                         "copy"
                         (do
                           (util/copy-to-clipboard!
-                            (or (:text content) (.toString range)))
+                            (or (:text content) (.toString selection)))
                           (pdf-utils/clear-all-selection))
 
                         "link"
@@ -310,6 +312,7 @@
           :on-context-menu open-tip!}]))))
 
 (rum/defc pdf-highlights-region-container
+  "Displays the highlights over a pdf document."
   [^js viewer page-hls ops]
 
   [:div.hls-region-container
@@ -453,9 +456,9 @@
   (let [^js doc (.-ownerDocument el)
         ^js win (.-defaultView doc)
         *mounted (rum/use-ref false)
-        [sel-state, set-sel-state!] (rum/use-state {:range nil :collapsed nil :point nil})
+        [sel-state, set-sel-state!] (rum/use-state {:selection nil :range nil :collapsed nil :point nil})
         [highlights, set-highlights!] (rum/use-state initial-hls)
-        [tip-state, set-tip-state!] (rum/use-state {:highlight nil :vw-pos nil :range nil :point nil :reset-fn nil})
+        [tip-state, set-tip-state!] (rum/use-state {:highlight nil :vw-pos nil :selection nil :point nil :reset-fn nil})
 
         clear-ctx-tip! (rum/use-callback
                          #(let [reset-fn (:reset-fn tip-state)]
@@ -509,7 +512,12 @@
                     (set-sel-state! {:collapsed true})
 
                     (and sel-range (.contains el (.-commonAncestorContainer sel-range)))
-                    (set-sel-state! {:collapsed false :range sel-range :point {:x (.-clientX e) :y (.-clientY e)}}))))
+                    ;; NOTE: `Range.toString()` forgets newlines whereas `Selection.toString()`
+                    ;; preserves them, so we derive text contents from the selection. However
+                    ;; `Document.getSelection()` seems to return the same object across multiple
+                    ;; selection changes, so we use the range as the `use-effect!` dep. Thus,
+                    ;; we need to store both the selection and the range.
+                    (set-sel-state! {:collapsed false :selection selection :range sel-range :point {:x (.-clientX e) :y (.-clientY e)}}))))
 
               fn-selection
               (fn []
@@ -549,8 +557,9 @@
     ;; selection context menu
     (rum/use-effect!
       (fn []
-        (when-let [^js sel-range (and (not (:collapsed sel-state)) (:range sel-state))]
+        (when-let [^js/Range sel-range (and (not (:collapsed sel-state)) (:range sel-state))]
           (let [^js point (:point sel-state)
+                ^js/Selection selection (:selection sel-state)
                 hl-fn #(when-let [page-info (pdf-utils/get-page-from-range sel-range)]
                          (when-let [sel-rects (pdf-utils/get-range-rects<-page-cnt sel-range (:page-el page-info))]
                            (let [page (int (:page-number page-info))
@@ -563,16 +572,15 @@
                              ;;(dd "[Range] ====> [" page-info "]" (.toString sel-range) point)
                              ;;(dd "[Rects] ====>" sel-rects " [Bounding] ====>" bounding)
 
-
                              {:id         nil
                               :page       page
                               :position   sc-pos
-                              :content    {:text (.toString sel-range)}
+                              :content    {:text (.toString selection)}
                               :properties {}})))]
 
             ;; show ctx menu
             (set-tip-state! {:highlight hl-fn
-                             :range     sel-range
+                             :selection selection
                              :point     point}))))
 
       [(:range sel-state)])
@@ -947,7 +955,6 @@
                                 #js {:container            el
                                      :eventBus             event-bus
                                      :linkService          link-service
-                                     :enhanceTextSelection true
                                      :textLayerMode        2
                                      :removePageBorders    true})]
                (. link-service setDocument pdf-document)

src/main/frontend/extensions/pdf/pdf.css

@@ -269,7 +269,6 @@ input::-webkit-inner-spin-button {
   }
 
   &-hls-text-region {
-    position: absolute;
     opacity: 1;
     z-index: 2;
   }