pdfjs-dist 2.6.347 → 2.7.570

package/lib/web/app.js

@@ -24,7 +24,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.PDFPrintServiceFactory = exports.DefaultExternalServices = exports.PDFViewerApplication = void 0;
+exports.PDFViewerApplication = exports.PDFPrintServiceFactory = exports.DefaultExternalServices = void 0;
 
 var _ui_utils = require("./ui_utils.js");
 
@@ -36,8 +36,6 @@ var _pdf_cursor_tools = require("./pdf_cursor_tools.js");
 
 var _pdf_rendering_queue = require("./pdf_rendering_queue.js");
 
-var _pdf_sidebar = require("./pdf_sidebar.js");
-
 var _overlay_manager = require("./overlay_manager.js");
 
 var _password_prompt = require("./password_prompt.js");
@@ -60,6 +58,8 @@ var _pdf_outline_viewer = require("./pdf_outline_viewer.js");
 
 var _pdf_presentation_mode = require("./pdf_presentation_mode.js");
 
+var _pdf_sidebar = require("./pdf_sidebar.js");
+
 var _pdf_sidebar_resizer = require("./pdf_sidebar_resizer.js");
 
 var _pdf_thumbnail_viewer = require("./pdf_thumbnail_viewer.js");
@@ -84,6 +84,11 @@ const ViewOnLoad = {
   PREVIOUS: 0,
   INITIAL: 1
 };
+const ViewerCssTheme = {
+  AUTOMATIC: 0,
+  LIGHT: 1,
+  DARK: 2
+};
 const KNOWN_VERSIONS = ["1.0", "1.1", "1.2", "1.3", "1.4", "1.5", "1.6", "1.7", "1.8", "1.9", "2.0", "2.1", "2.2", "2.3"];
 const KNOWN_GENERATORS = ["acrobat distiller", "acrobat pdfwriter", "adobe livecycle", "adobe pdf library", "adobe photoshop", "ghostscript", "tcpdf", "cairo", "dvipdfm", "dvips", "pdftex", "pdfkit", "itext", "prince", "quarkxpress", "mac os x", "microsoft", "openoffice", "oracle", "luradocument", "pdf-xchange", "antenna house", "aspose.cells", "fpdf"];
 
@@ -98,7 +103,7 @@ class DefaultExternalServices {
 
   static initPassiveLoading(callbacks) {}
 
-  static fallback(data, callback) {}
+  static async fallback(data) {}
 
   static reportTelemetry(data) {}
 
@@ -114,6 +119,10 @@ class DefaultExternalServices {
     throw new Error("Not implemented: createL10n");
   }
 
+  static createScripting(options) {
+    throw new Error("Not implemented: createScripting");
+  }
+
   static get supportsIntegratedFind() {
     return (0, _pdf.shadow)(this, "supportsIntegratedFind", false);
   }
@@ -171,17 +180,26 @@ const PDFViewerApplication = {
   url: "",
   baseUrl: "",
   externalServices: DefaultExternalServices,
-  _boundEvents: {},
-  contentDispositionFilename: null,
+  _boundEvents: Object.create(null),
+  documentInfo: null,
+  metadata: null,
+  _contentDispositionFilename: null,
+  _contentLength: null,
   triggerDelayedFallback: null,
   _saveInProgress: false,
   _wheelUnusedTicks: 0,
+  _idleCallbacks: new Set(),
+  _scriptingInstance: null,
+  _mouseState: Object.create(null),
 
   async initialize(appConfig) {
     this.preferences = this.externalServices.createPreferences();
     this.appConfig = appConfig;
     await this._readPreferences();
     await this._parseHashParameters();
+
+    this._forceCssTheme();
+
     await this._initializeL10n();
 
     if (this.isViewerEmbedded && _app_options.AppOptions.get("externalLinkTarget") === _pdf.LinkTarget.NONE) {
@@ -207,13 +225,9 @@ const PDFViewerApplication = {
     }
 
     try {
-      const prefs = await this.preferences.getAll();
-
-      for (const name in prefs) {
-        _app_options.AppOptions.set(name, prefs[name]);
-      }
+      _app_options.AppOptions.setAll(await this.preferences.getAll());
     } catch (reason) {
-      console.error(`_readPreferences: "${reason.message}".`);
+      console.error(`_readPreferences: "${reason?.message}".`);
     }
   },
 
@@ -292,6 +306,10 @@ const PDFViewerApplication = {
       _app_options.AppOptions.set("locale", hashParams.locale);
     }
 
+    if (waitOn.length === 0) {
+      return undefined;
+    }
+
     return Promise.all(waitOn).catch(reason => {
       console.error(`_parseHashParameters: "${reason.message}".`);
     });
@@ -305,6 +323,41 @@ const PDFViewerApplication = {
     document.getElementsByTagName("html")[0].dir = dir;
   },
 
+  _forceCssTheme() {
+    const cssTheme = _app_options.AppOptions.get("viewerCssTheme");
+
+    if (cssTheme === ViewerCssTheme.AUTOMATIC || !Object.values(ViewerCssTheme).includes(cssTheme)) {
+      return;
+    }
+
+    try {
+      const styleSheet = document.styleSheets[0];
+      const cssRules = styleSheet?.cssRules || [];
+
+      for (let i = 0, ii = cssRules.length; i < ii; i++) {
+        const rule = cssRules[i];
+
+        if (rule instanceof CSSMediaRule && rule.media?.[0] === "(prefers-color-scheme: dark)") {
+          if (cssTheme === ViewerCssTheme.LIGHT) {
+            styleSheet.deleteRule(i);
+            return;
+          }
+
+          const darkRules = /^@media \(prefers-color-scheme: dark\) {\n\s*([\w\s-.,:;/\\{}()]+)\n}$/.exec(rule.cssText);
+
+          if (darkRules?.[1]) {
+            styleSheet.deleteRule(i);
+            styleSheet.insertRule(darkRules[1], i);
+          }
+
+          return;
+        }
+      }
+    } catch (reason) {
+      console.error(`_forceCssTheme: "${reason?.message}".`);
+    }
+  },
+
   async _initializeViewerComponents() {
     const appConfig = this.appConfig;
     const eventBus = appConfig.eventBus || new _ui_utils.EventBus({
@@ -347,7 +400,9 @@ const PDFViewerApplication = {
       renderInteractiveForms: _app_options.AppOptions.get("renderInteractiveForms"),
       enablePrintAutoRotate: _app_options.AppOptions.get("enablePrintAutoRotate"),
       useOnlyCssZoom: _app_options.AppOptions.get("useOnlyCssZoom"),
-      maxCanvasPixels: _app_options.AppOptions.get("maxCanvasPixels")
+      maxCanvasPixels: _app_options.AppOptions.get("maxCanvasPixels"),
+      enableScripting: _app_options.AppOptions.get("enableScripting"),
+      mouseState: this._mouseState
     });
     pdfRenderingQueue.setViewer(this.pdfViewer);
     pdfLinkService.setViewer(this.pdfViewer);
@@ -478,10 +533,6 @@ const PDFViewerApplication = {
     this.pdfViewer.currentPageNumber = val;
   },
 
-  get printing() {
-    return !!this.printService;
-  },
-
   get supportsPrinting() {
     return PDFPrintServiceFactory.instance.supportsPrinting;
   },
@@ -489,9 +540,9 @@ const PDFViewerApplication = {
   get supportsFullscreen() {
     let support;
     const doc = document.documentElement;
-    support = !!(doc.requestFullscreen || doc.mozRequestFullScreen || doc.webkitRequestFullScreen || doc.msRequestFullscreen);
+    support = !!(doc.requestFullscreen || doc.mozRequestFullScreen || doc.webkitRequestFullScreen);
 
-    if (document.fullscreenEnabled === false || document.mozFullScreenEnabled === false || document.webkitFullscreenEnabled === false || document.msFullscreenEnabled === false) {
+    if (document.fullscreenEnabled === false || document.mozFullScreenEnabled === false || document.webkitFullscreenEnabled === false) {
       support = false;
     }
 
@@ -543,6 +594,52 @@ const PDFViewerApplication = {
     document.title = title;
   },
 
+  get _docFilename() {
+    return this._contentDispositionFilename || (0, _ui_utils.getPDFFileNameFromURL)(this.url);
+  },
+
+  _cancelIdleCallbacks() {
+    if (!this._idleCallbacks.size) {
+      return;
+    }
+
+    for (const callback of this._idleCallbacks) {
+      window.cancelIdleCallback(callback);
+    }
+
+    this._idleCallbacks.clear();
+  },
+
+  async _destroyScriptingInstance() {
+    if (!this._scriptingInstance) {
+      return;
+    }
+
+    const {
+      scripting,
+      internalEvents,
+      domEvents
+    } = this._scriptingInstance;
+
+    try {
+      await scripting.destroySandbox();
+    } catch (ex) {}
+
+    for (const [name, listener] of internalEvents) {
+      this.eventBus._off(name, listener);
+    }
+
+    internalEvents.clear();
+
+    for (const [name, listener] of domEvents) {
+      window.removeEventListener(name, listener);
+    }
+
+    domEvents.clear();
+    delete this._mouseState.isDown;
+    this._scriptingInstance = null;
+  },
+
   async close() {
     const errorWrapper = this.appConfig.errorWrapper.container;
     errorWrapper.setAttribute("hidden", "true");
@@ -551,7 +648,8 @@ const PDFViewerApplication = {
       return undefined;
     }
 
-    const promise = this.pdfLoadingTask.destroy();
+    const promises = [];
+    promises.push(this.pdfLoadingTask.destroy());
     this.pdfLoadingTask = null;
 
     if (this.pdfDocument) {
@@ -568,9 +666,16 @@ const PDFViewerApplication = {
     this.downloadComplete = false;
     this.url = "";
     this.baseUrl = "";
-    this.contentDispositionFilename = null;
+    this.documentInfo = null;
+    this.metadata = null;
+    this._contentDispositionFilename = null;
+    this._contentLength = null;
     this.triggerDelayedFallback = null;
     this._saveInProgress = false;
+
+    this._cancelIdleCallbacks();
+
+    promises.push(this._destroyScriptingInstance());
     this.pdfSidebar.reset();
     this.pdfOutlineViewer.reset();
     this.pdfAttachmentViewer.reset();
@@ -591,7 +696,8 @@ const PDFViewerApplication = {
       PDFBug.cleanup();
     }
 
-    return promise;
+    await Promise.all(promises);
+    return undefined;
   },
 
   async open(file, args) {
@@ -629,13 +735,7 @@ const PDFViewerApplication = {
 
     if (args) {
       for (const key in args) {
-        const value = args[key];
-
-        if (key === "length") {
-          this.pdfDocumentProperties.setFileSize(value);
-        }
-
-        parameters[key] = value;
+        parameters[key] = args[key];
       }
     }
 
@@ -663,7 +763,7 @@ const PDFViewerApplication = {
         return undefined;
       }
 
-      const message = exception && exception.message;
+      const message = exception?.message;
       let loadingErrorMessage;
 
       if (exception instanceof _pdf.InvalidPDFException) {
@@ -692,13 +792,9 @@ const PDFViewerApplication = {
       downloadManager.downloadUrl(url, filename);
     }
 
-    const url = this.baseUrl;
-    const filename = this.contentDispositionFilename || (0, _ui_utils.getPDFFileNameFromURL)(this.url);
-    const downloadManager = this.downloadManager;
-
-    downloadManager.onerror = err => {
-      this.error(`PDF failed to download: ${err}`);
-    };
+    const downloadManager = this.downloadManager,
+          url = this.baseUrl,
+          filename = this._docFilename;
 
     if (!this.pdfDocument || !this.downloadComplete) {
       downloadByUrl();
@@ -713,20 +809,16 @@ const PDFViewerApplication = {
     }).catch(downloadByUrl);
   },
 
-  save({
+  async save({
     sourceEventType = "download"
   } = {}) {
     if (this._saveInProgress) {
       return;
     }
 
-    const url = this.baseUrl;
-    const filename = this.contentDispositionFilename || (0, _ui_utils.getPDFFileNameFromURL)(this.url);
-    const downloadManager = this.downloadManager;
-
-    downloadManager.onerror = err => {
-      this.error(`PDF failed to be saved: ${err}`);
-    };
+    const downloadManager = this.downloadManager,
+          url = this.baseUrl,
+          filename = this._docFilename;
 
     if (!this.pdfDocument || !this.downloadComplete) {
       this.download({
@@ -736,6 +828,10 @@ const PDFViewerApplication = {
     }
 
     this._saveInProgress = true;
+    await this._scriptingInstance?.scripting.dispatchEventInSandbox({
+      id: "doc",
+      name: "WillSave"
+    });
     this.pdfDocument.saveDocument(this.pdfDocument.annotationStorage).then(data => {
       const blob = new Blob([data], {
         type: "application/pdf"
@@ -745,11 +841,23 @@ const PDFViewerApplication = {
       this.download({
         sourceEventType
       });
-    }).finally(() => {
+    }).finally(async () => {
+      await this._scriptingInstance?.scripting.dispatchEventInSandbox({
+        id: "doc",
+        name: "DidSave"
+      });
       this._saveInProgress = false;
     });
   },
 
+  downloadOrSave(options) {
+    if (this.pdfDocument?.annotationStorage.size > 0) {
+      this.save(options);
+    } else {
+      this.download(options);
+    }
+  },
+
   _delayedFallback(featureId) {
     this.externalServices.reportTelemetry({
       type: "unsupportedFeature",
@@ -778,12 +886,12 @@ const PDFViewerApplication = {
     this.externalServices.fallback({
       featureId,
       url: this.baseUrl
-    }, function response(download) {
+    }).then(download => {
       if (!download) {
         return;
       }
 
-      PDFViewerApplication.download({
+      this.download({
         sourceEventType: "download"
       });
     });
@@ -885,7 +993,10 @@ const PDFViewerApplication = {
 
   load(pdfDocument) {
     this.pdfDocument = pdfDocument;
-    pdfDocument.getDownloadInfo().then(() => {
+    pdfDocument.getDownloadInfo().then(({
+      length
+    }) => {
+      this._contentLength = length;
       this.downloadComplete = true;
       this.loadingBar.hide();
       firstPagePromise.then(() => {
@@ -903,16 +1014,6 @@ const PDFViewerApplication = {
     baseDocumentUrl = null;
     this.pdfLinkService.setDocument(pdfDocument, baseDocumentUrl);
     this.pdfDocumentProperties.setDocument(pdfDocument, this.url);
-    const annotationStorage = pdfDocument.annotationStorage;
-
-    annotationStorage.onSetModified = function () {
-      window.addEventListener("beforeunload", beforeUnload);
-    };
-
-    annotationStorage.onResetModified = function () {
-      window.removeEventListener("beforeunload", beforeUnload);
-    };
-
     const pdfViewer = this.pdfViewer;
     pdfViewer.setDocument(pdfDocument);
     const {
@@ -928,7 +1029,7 @@ const PDFViewerApplication = {
       scrollLeft: "0",
       scrollTop: "0",
       rotation: null,
-      sidebarView: _pdf_sidebar.SidebarView.UNKNOWN,
+      sidebarView: _ui_utils.SidebarView.UNKNOWN,
       scrollMode: _ui_utils.ScrollMode.UNKNOWN,
       spreadMode: _ui_utils.SpreadMode.UNKNOWN
     }).catch(() => {
@@ -936,6 +1037,9 @@ const PDFViewerApplication = {
     });
     firstPagePromise.then(pdfPage => {
       this.loadingBar.setWidth(this.appConfig.viewerContainer);
+
+      this._initializeAnnotationStorageCallbacks(pdfDocument);
+
       Promise.all([_ui_utils.animationStarted, storedPromise, pageLayoutPromise, pageModePromise, openActionPromise]).then(async ([timeStamp, stored, pageLayout, pageMode, openAction]) => {
         const viewOnLoad = _app_options.AppOptions.get("viewOnLoad");
 
@@ -962,7 +1066,7 @@ const PDFViewerApplication = {
           hash = `page=${stored.page}&zoom=${zoom || stored.zoom},` + `${stored.scrollLeft},${stored.scrollTop}`;
           rotation = parseInt(stored.rotation, 10);
 
-          if (sidebarView === _pdf_sidebar.SidebarView.UNKNOWN) {
+          if (sidebarView === _ui_utils.SidebarView.UNKNOWN) {
             sidebarView = stored.sidebarView | 0;
           }
 
@@ -975,7 +1079,7 @@ const PDFViewerApplication = {
           }
         }
 
-        if (pageMode && sidebarView === _pdf_sidebar.SidebarView.UNKNOWN) {
+        if (pageMode && sidebarView === _ui_utils.SidebarView.UNKNOWN) {
           sidebarView = apiPageModeToSidebarView(pageMode);
         }
 
@@ -1026,7 +1130,8 @@ const PDFViewerApplication = {
     onePageRendered.then(() => {
       pdfDocument.getOutline().then(outline => {
         this.pdfOutlineViewer.render({
-          outline
+          outline,
+          pdfDocument
         });
       });
       pdfDocument.getAttachments().then(attachments => {
@@ -1040,6 +1145,20 @@ const PDFViewerApplication = {
           pdfDocument
         });
       });
+
+      if ("requestIdleCallback" in window) {
+        const callback = window.requestIdleCallback(() => {
+          this._collectTelemetry(pdfDocument);
+
+          this._idleCallbacks.delete(callback);
+        }, {
+          timeout: 1000
+        });
+
+        this._idleCallbacks.add(callback);
+      }
+
+      this._initializeJavaScript(pdfDocument);
     });
 
     this._initializePageLabels(pdfDocument);
@@ -1047,8 +1166,261 @@ const PDFViewerApplication = {
     this._initializeMetadata(pdfDocument);
   },
 
+  async _initializeJavaScript(pdfDocument) {
+    if (!_app_options.AppOptions.get("enableScripting")) {
+      return;
+    }
+
+    const [objects, calculationOrder, docActions] = await Promise.all([pdfDocument.getFieldObjects(), pdfDocument.getCalculationOrderIds(), pdfDocument.getJSActions()]);
+
+    if (!objects && !docActions) {
+      return;
+    }
+
+    if (pdfDocument !== this.pdfDocument) {
+      return;
+    }
+
+    const scripting = this.externalServices.createScripting({
+      sandboxBundleSrc: _app_options.AppOptions.get("sandboxBundleSrc")
+    });
+    const internalEvents = new Map(),
+          domEvents = new Map();
+    this._scriptingInstance = {
+      scripting,
+      ready: false,
+      internalEvents,
+      domEvents
+    };
+
+    if (!this.documentInfo) {
+      await new Promise(resolve => {
+        this.eventBus._on("metadataloaded", evt => {
+          resolve();
+        }, {
+          once: true
+        });
+      });
+
+      if (pdfDocument !== this.pdfDocument) {
+        return;
+      }
+    }
+
+    if (!this._contentLength) {
+      await new Promise(resolve => {
+        this.eventBus._on("documentloaded", evt => {
+          resolve();
+        }, {
+          once: true
+        });
+      });
+
+      if (pdfDocument !== this.pdfDocument) {
+        return;
+      }
+    }
+
+    const updateFromSandbox = ({
+      detail
+    }) => {
+      const {
+        id,
+        command,
+        value
+      } = detail;
+
+      if (!id) {
+        switch (command) {
+          case "clear":
+            console.clear();
+            break;
+
+          case "error":
+            console.error(value);
+            break;
+
+          case "layout":
+            this.pdfViewer.spreadMode = apiPageLayoutToSpreadMode(value);
+            break;
+
+          case "page-num":
+            this.pdfViewer.currentPageNumber = value + 1;
+            break;
+
+          case "print":
+            this.pdfViewer.pagesPromise.then(() => {
+              this.triggerPrinting();
+            });
+            break;
+
+          case "println":
+            console.log(value);
+            break;
+
+          case "zoom":
+            this.pdfViewer.currentScaleValue = value;
+            break;
+        }
+
+        return;
+      }
+
+      const element = document.getElementById(id);
+
+      if (element) {
+        element.dispatchEvent(new CustomEvent("updatefromsandbox", {
+          detail
+        }));
+      } else {
+        if (value !== undefined && value !== null) {
+          pdfDocument.annotationStorage.setValue(id, value);
+        }
+      }
+    };
+
+    internalEvents.set("updatefromsandbox", updateFromSandbox);
+    const visitedPages = new Map();
+
+    const pageOpen = ({
+      pageNumber,
+      actionsPromise
+    }) => {
+      visitedPages.set(pageNumber, (async () => {
+        let actions = null;
+
+        if (!visitedPages.has(pageNumber)) {
+          actions = await actionsPromise;
+
+          if (pdfDocument !== this.pdfDocument) {
+            return;
+          }
+        }
+
+        await this._scriptingInstance?.scripting.dispatchEventInSandbox({
+          id: "page",
+          name: "PageOpen",
+          pageNumber,
+          actions
+        });
+      })());
+    };
+
+    const pageClose = async ({
+      pageNumber
+    }) => {
+      const actionsPromise = visitedPages.get(pageNumber);
+
+      if (!actionsPromise) {
+        return;
+      }
+
+      visitedPages.set(pageNumber, null);
+      await actionsPromise;
+
+      if (pdfDocument !== this.pdfDocument) {
+        return;
+      }
+
+      await this._scriptingInstance?.scripting.dispatchEventInSandbox({
+        id: "page",
+        name: "PageClose",
+        pageNumber
+      });
+    };
+
+    internalEvents.set("pageopen", pageOpen);
+    internalEvents.set("pageclose", pageClose);
+
+    const dispatchEventInSandbox = ({
+      detail
+    }) => {
+      scripting.dispatchEventInSandbox(detail);
+    };
+
+    internalEvents.set("dispatcheventinsandbox", dispatchEventInSandbox);
+
+    const mouseDown = event => {
+      this._mouseState.isDown = true;
+    };
+
+    domEvents.set("mousedown", mouseDown);
+
+    const mouseUp = event => {
+      this._mouseState.isDown = false;
+    };
+
+    domEvents.set("mouseup", mouseUp);
+
+    for (const [name, listener] of internalEvents) {
+      this.eventBus._on(name, listener);
+    }
+
+    for (const [name, listener] of domEvents) {
+      window.addEventListener(name, listener);
+    }
+
+    try {
+      await scripting.createSandbox({
+        objects,
+        calculationOrder,
+        appInfo: {
+          platform: navigator.platform,
+          language: navigator.language
+        },
+        docInfo: { ...this.documentInfo,
+          baseURL: this.baseUrl,
+          filesize: this._contentLength,
+          filename: this._docFilename,
+          metadata: this.metadata?.getRaw(),
+          authors: this.metadata?.get("dc:creator"),
+          numPages: pdfDocument.numPages,
+          URL: this.url,
+          actions: docActions
+        }
+      });
+
+      if (this.externalServices.isInAutomation) {
+        this.eventBus.dispatch("sandboxcreated", {
+          source: this
+        });
+      }
+    } catch (error) {
+      console.error(`_initializeJavaScript: "${error?.message}".`);
+
+      this._destroyScriptingInstance();
+
+      return;
+    }
+
+    await scripting.dispatchEventInSandbox({
+      id: "doc",
+      name: "Open"
+    });
+    await this.pdfViewer.initializeScriptingEvents();
+    Promise.resolve().then(() => {
+      if (this._scriptingInstance) {
+        this._scriptingInstance.ready = true;
+      }
+    });
+  },
+
+  async _collectTelemetry(pdfDocument) {
+    const markInfo = await this.pdfDocument.getMarkInfo();
+
+    if (pdfDocument !== this.pdfDocument) {
+      return;
+    }
+
+    const tagged = markInfo?.Marked || false;
+    this.externalServices.reportTelemetry({
+      type: "tagged",
+      tagged
+    });
+  },
+
   async _initializeAutoPrint(pdfDocument, openActionPromise) {
-    const [openAction, javaScript] = await Promise.all([openActionPromise, pdfDocument.getJavaScript()]);
+    const [openAction, javaScript] = await Promise.all([openActionPromise, !_app_options.AppOptions.get("enableScripting") ? pdfDocument.getJavaScript() : null]);
 
     if (pdfDocument !== this.pdfDocument) {
       return;
@@ -1056,7 +1428,7 @@ const PDFViewerApplication = {
 
     let triggerAutoPrint = false;
 
-    if (openAction && openAction.action === "Print") {
+    if (openAction?.action === "Print") {
       triggerAutoPrint = true;
     }
 
@@ -1083,14 +1455,8 @@ const PDFViewerApplication = {
       }
     }
 
-    if (!this.supportsPrinting) {
-      return;
-    }
-
     if (triggerAutoPrint) {
-      setTimeout(function () {
-        window.print();
-      });
+      this.triggerPrinting();
     }
   },
 
@@ -1098,7 +1464,8 @@ const PDFViewerApplication = {
     const {
       info,
       metadata,
-      contentDispositionFilename
+      contentDispositionFilename,
+      contentLength
     } = await pdfDocument.getMetadata();
 
     if (pdfDocument !== this.pdfDocument) {
@@ -1107,7 +1474,8 @@ const PDFViewerApplication = {
 
     this.documentInfo = info;
     this.metadata = metadata;
-    this.contentDispositionFilename = contentDispositionFilename;
+    this._contentDispositionFilename = contentDispositionFilename;
+    this._contentLength ?? (this._contentLength = contentLength);
     console.log(`PDF ${pdfDocument.fingerprint} [${info.PDFFormatVersion} ` + `${(info.Producer || "-").trim()} / ${(info.Creator || "-").trim()}] ` + `(PDF.js: ${_pdf.version || "-"}` + `${this.pdfViewer.enableWebGL ? " [WebGL]" : ""})`);
     let pdfTitle;
     const infoTitle = info && info.Title;
@@ -1155,7 +1523,7 @@ const PDFViewerApplication = {
           return false;
         }
 
-        generatorId = generator.replace(/[ .\-]/g, "_");
+        generatorId = generator.replace(/[ .-]/g, "_");
         return true;
       });
     }
@@ -1174,6 +1542,9 @@ const PDFViewerApplication = {
       generator: generatorId,
       formType
     });
+    this.eventBus.dispatch("metadataloaded", {
+      source: this
+    });
   },
 
   async _initializePageLabels(pdfDocument) {
@@ -1260,6 +1631,24 @@ const PDFViewerApplication = {
     }
   },
 
+  _initializeAnnotationStorageCallbacks(pdfDocument) {
+    if (pdfDocument !== this.pdfDocument) {
+      return;
+    }
+
+    const {
+      annotationStorage
+    } = pdfDocument;
+
+    annotationStorage.onSetModified = function () {
+      window.addEventListener("beforeunload", beforeUnload);
+    };
+
+    annotationStorage.onResetModified = function () {
+      window.removeEventListener("beforeunload", beforeUnload);
+    };
+  },
+
   setInitialView(storedHash, {
     rotation,
     sidebarView,
@@ -1318,12 +1707,17 @@ const PDFViewerApplication = {
   },
 
   forceRendering() {
-    this.pdfRenderingQueue.printing = this.printing;
+    this.pdfRenderingQueue.printing = !!this.printService;
     this.pdfRenderingQueue.isThumbnailViewEnabled = this.pdfSidebar.isThumbnailViewVisible;
     this.pdfRenderingQueue.renderHighestPriority();
   },
 
   beforePrint() {
+    this._scriptingInstance?.scripting.dispatchEventInSandbox({
+      id: "doc",
+      name: "WillPrint"
+    });
+
     if (this.printService) {
       return;
     }
@@ -1358,6 +1752,11 @@ const PDFViewerApplication = {
   },
 
   afterPrint() {
+    this._scriptingInstance?.scripting.dispatchEventInSandbox({
+      id: "doc",
+      name: "DidPrint"
+    });
+
     if (this.printService) {
       this.printService.destroy();
       this.printService = null;
@@ -1387,6 +1786,14 @@ const PDFViewerApplication = {
     this.pdfPresentationMode.request();
   },
 
+  triggerPrinting() {
+    if (!this.supportsPrinting) {
+      return;
+    }
+
+    window.print();
+  },
+
   bindEvents() {
     const {
       eventBus,
@@ -1471,6 +1878,14 @@ const PDFViewerApplication = {
 
     eventBus._on("updatefindcontrolstate", webViewerUpdateFindControlState);
 
+    if (_app_options.AppOptions.get("pdfBug")) {
+      _boundEvents.reportPageStatsPDFBug = reportPageStatsPDFBug;
+
+      eventBus._on("pagerendered", _boundEvents.reportPageStatsPDFBug);
+
+      eventBus._on("pagechanging", _boundEvents.reportPageStatsPDFBug);
+    }
+
     eventBus._on("fileinputchange", webViewerFileInputChange);
 
     eventBus._on("openfile", webViewerOpenFile);
@@ -1507,6 +1922,13 @@ const PDFViewerApplication = {
       });
     };
 
+    _boundEvents.windowUpdateFromSandbox = event => {
+      eventBus.dispatch("updatefromsandbox", {
+        source: window,
+        detail: event.detail
+      });
+    };
+
     window.addEventListener("visibilitychange", webViewerVisibilityChange);
     window.addEventListener("wheel", webViewerWheel, {
       passive: false
@@ -1521,6 +1943,7 @@ const PDFViewerApplication = {
     window.addEventListener("hashchange", _boundEvents.windowHashChange);
     window.addEventListener("beforeprint", _boundEvents.windowBeforePrint);
     window.addEventListener("afterprint", _boundEvents.windowAfterPrint);
+    window.addEventListener("updatefromsandbox", _boundEvents.windowUpdateFromSandbox);
   },
 
   unbindEvents() {
@@ -1605,6 +2028,14 @@ const PDFViewerApplication = {
 
     eventBus._off("updatefindcontrolstate", webViewerUpdateFindControlState);
 
+    if (_boundEvents.reportPageStatsPDFBug) {
+      eventBus._off("pagerendered", _boundEvents.reportPageStatsPDFBug);
+
+      eventBus._off("pagechanging", _boundEvents.reportPageStatsPDFBug);
+
+      _boundEvents.reportPageStatsPDFBug = null;
+    }
+
     eventBus._off("fileinputchange", webViewerFileInputChange);
 
     eventBus._off("openfile", webViewerOpenFile);
@@ -1631,10 +2062,12 @@ const PDFViewerApplication = {
     window.removeEventListener("hashchange", _boundEvents.windowHashChange);
     window.removeEventListener("beforeprint", _boundEvents.windowBeforePrint);
     window.removeEventListener("afterprint", _boundEvents.windowAfterPrint);
+    window.removeEventListener("updatefromsandbox", _boundEvents.windowUpdateFromSandbox);
     _boundEvents.windowResize = null;
     _boundEvents.windowHashChange = null;
     _boundEvents.windowBeforePrint = null;
     _boundEvents.windowAfterPrint = null;
+    _boundEvents.windowUpdateFromSandbox = null;
   },
 
   accumulateWheelTicks(ticks) {
@@ -1646,6 +2079,10 @@ const PDFViewerApplication = {
     const wholeTicks = Math.sign(this._wheelUnusedTicks) * Math.floor(Math.abs(this._wheelUnusedTicks));
     this._wheelUnusedTicks -= wholeTicks;
     return wholeTicks;
+  },
+
+  get scriptingReady() {
+    return this._scriptingInstance?.ready || false;
   }
 
 };
@@ -1704,6 +2141,23 @@ function loadAndEnablePDFBug(enabledTabs) {
   });
 }
 
+function reportPageStatsPDFBug({
+  pageNumber
+}) {
+  if (typeof Stats === "undefined" || !Stats.enabled) {
+    return;
+  }
+
+  const pageView = PDFViewerApplication.pdfViewer.getPageView(pageNumber - 1);
+  const pageStats = pageView && pageView.pdfPage && pageView.pdfPage.stats;
+
+  if (!pageStats) {
+    return;
+  }
+
+  Stats.add(pageNumber, pageStats);
+}
+
 function webViewerInitialized() {
   const appConfig = PDFViewerApplication.appConfig;
   let file;
@@ -1829,37 +2283,33 @@ function webViewerResetPermissions() {
   appConfig.viewerContainer.classList.remove(ENABLE_PERMISSIONS_CLASS);
 }
 
-function webViewerPageRendered(evt) {
-  const pageNumber = evt.pageNumber;
-  const pageIndex = pageNumber - 1;
-  const pageView = PDFViewerApplication.pdfViewer.getPageView(pageIndex);
-
+function webViewerPageRendered({
+  pageNumber,
+  timestamp,
+  error
+}) {
   if (pageNumber === PDFViewerApplication.page) {
     PDFViewerApplication.toolbar.updateLoadingIndicatorState(false);
   }
 
-  if (!pageView) {
-    return;
-  }
-
   if (PDFViewerApplication.pdfSidebar.isThumbnailViewVisible) {
-    const thumbnailView = PDFViewerApplication.pdfThumbnailViewer.getThumbnail(pageIndex);
-    thumbnailView.setImage(pageView);
-  }
+    const pageView = PDFViewerApplication.pdfViewer.getPageView(pageNumber - 1);
+    const thumbnailView = PDFViewerApplication.pdfThumbnailViewer.getThumbnail(pageNumber - 1);
 
-  if (typeof Stats !== "undefined" && Stats.enabled && pageView.stats) {
-    Stats.add(pageNumber, pageView.stats);
+    if (pageView && thumbnailView) {
+      thumbnailView.setImage(pageView);
+    }
   }
 
-  if (pageView.error) {
+  if (error) {
     PDFViewerApplication.l10n.get("rendering_error", null, "An error occurred while rendering the page.").then(msg => {
-      PDFViewerApplication.error(msg, pageView.error);
+      PDFViewerApplication.error(msg, error);
     });
   }
 
   PDFViewerApplication.externalServices.reportTelemetry({
     type: "pageInfo",
-    timestamp: evt.timestamp
+    timestamp
   });
   PDFViewerApplication.pdfDocument.getStats().then(function (stats) {
     PDFViewerApplication.externalServices.reportTelemetry({
@@ -1876,24 +2326,24 @@ function webViewerPageMode({
 
   switch (mode) {
     case "thumbs":
-      view = _pdf_sidebar.SidebarView.THUMBS;
+      view = _ui_utils.SidebarView.THUMBS;
       break;
 
     case "bookmarks":
     case "outline":
-      view = _pdf_sidebar.SidebarView.OUTLINE;
+      view = _ui_utils.SidebarView.OUTLINE;
       break;
 
     case "attachments":
-      view = _pdf_sidebar.SidebarView.ATTACHMENTS;
+      view = _ui_utils.SidebarView.ATTACHMENTS;
       break;
 
     case "layers":
-      view = _pdf_sidebar.SidebarView.LAYERS;
+      view = _ui_utils.SidebarView.LAYERS;
       break;
 
     case "none":
-      view = _pdf_sidebar.SidebarView.NONE;
+      view = _ui_utils.SidebarView.NONE;
       break;
 
     default:
@@ -1918,10 +2368,7 @@ function webViewerNamedAction(evt) {
       break;
 
     case "Print":
-      if (PDFViewerApplication.supportsPrinting) {
-        webViewerPrint();
-      }
-
+      PDFViewerApplication.triggerPrinting();
       break;
 
     case "SaveAs":
@@ -1930,19 +2377,8 @@ function webViewerNamedAction(evt) {
   }
 }
 
-function webViewerPresentationModeChanged({
-  active,
-  switchInProgress
-}) {
-  let state = _ui_utils.PresentationModeState.NORMAL;
-
-  if (switchInProgress) {
-    state = _ui_utils.PresentationModeState.CHANGING;
-  } else if (active) {
-    state = _ui_utils.PresentationModeState.FULLSCREEN;
-  }
-
-  PDFViewerApplication.pdfViewer.presentationModeState = state;
+function webViewerPresentationModeChanged(evt) {
+  PDFViewerApplication.pdfViewer.presentationModeState = evt.state;
 }
 
 function webViewerSidebarViewChanged(evt) {
@@ -1972,7 +2408,7 @@ function webViewerUpdateViewarea(evt) {
   PDFViewerApplication.appConfig.toolbar.viewBookmark.href = href;
   PDFViewerApplication.appConfig.secondaryToolbar.viewBookmarkButton.href = href;
   const currentPage = PDFViewerApplication.pdfViewer.getPageView(PDFViewerApplication.page - 1);
-  const loading = currentPage.renderingState !== _pdf_rendering_queue.RenderingStates.FINISHED;
+  const loading = (currentPage && currentPage.renderingState) !== _pdf_rendering_queue.RenderingStates.FINISHED;
   PDFViewerApplication.toolbar.updateLoadingIndicatorState(loading);
 }
 
@@ -2075,27 +2511,19 @@ function webViewerPresentationMode() {
 }
 
 function webViewerPrint() {
-  window.print();
-}
-
-function webViewerDownloadOrSave(sourceEventType) {
-  if (PDFViewerApplication.pdfDocument && PDFViewerApplication.pdfDocument.annotationStorage.size > 0) {
-    PDFViewerApplication.save({
-      sourceEventType
-    });
-  } else {
-    PDFViewerApplication.download({
-      sourceEventType
-    });
-  }
+  PDFViewerApplication.triggerPrinting();
 }
 
 function webViewerDownload() {
-  webViewerDownloadOrSave("download");
+  PDFViewerApplication.downloadOrSave({
+    sourceEventType: "download"
+  });
 }
 
 function webViewerSave() {
-  webViewerDownloadOrSave("save");
+  PDFViewerApplication.downloadOrSave({
+    sourceEventType: "save"
+  });
 }
 
 function webViewerFirstPage() {
@@ -2111,11 +2539,11 @@ function webViewerLastPage() {
 }
 
 function webViewerNextPage() {
-  PDFViewerApplication.page++;
+  PDFViewerApplication.pdfViewer.nextPage();
 }
 
 function webViewerPreviousPage() {
-  PDFViewerApplication.page--;
+  PDFViewerApplication.pdfViewer.previousPage();
 }
 
 function webViewerZoomIn() {
@@ -2134,7 +2562,7 @@ function webViewerPageNumberChanged(evt) {
   const pdfViewer = PDFViewerApplication.pdfViewer;
 
   if (evt.value !== "") {
-    pdfViewer.currentPageLabel = evt.value;
+    PDFViewerApplication.pdfLinkService.goToPage(evt.value);
   }
 
   if (evt.value !== pdfViewer.currentPageNumber.toString() && evt.value !== pdfViewer.currentPageLabel) {
@@ -2231,21 +2659,15 @@ function webViewerRotationChanging(evt) {
   PDFViewerApplication.pdfViewer.currentPageNumber = evt.pageNumber;
 }
 
-function webViewerPageChanging(evt) {
-  const page = evt.pageNumber;
-  PDFViewerApplication.toolbar.setPageNumber(page, evt.pageLabel || null);
-  PDFViewerApplication.secondaryToolbar.setPageNumber(page);
+function webViewerPageChanging({
+  pageNumber,
+  pageLabel
+}) {
+  PDFViewerApplication.toolbar.setPageNumber(pageNumber, pageLabel);
+  PDFViewerApplication.secondaryToolbar.setPageNumber(pageNumber);
 
   if (PDFViewerApplication.pdfSidebar.isThumbnailViewVisible) {
-    PDFViewerApplication.pdfThumbnailViewer.scrollThumbnailIntoView(page);
-  }
-
-  if (typeof Stats !== "undefined" && Stats.enabled) {
-    const pageView = PDFViewerApplication.pdfViewer.getPageView(page - 1);
-
-    if (pageView && pageView.stats) {
-      Stats.add(page, pageView.stats);
-    }
+    PDFViewerApplication.pdfThumbnailViewer.scrollThumbnailIntoView(pageNumber);
   }
 }
 
@@ -2364,7 +2786,7 @@ function webViewerKeyDown(evt) {
   if (cmd === 1 || cmd === 8 || cmd === 5 || cmd === 12) {
     switch (evt.keyCode) {
       case 70:
-        if (!PDFViewerApplication.supportsIntegratedFind) {
+        if (!PDFViewerApplication.supportsIntegratedFind && !evt.shiftKey) {
           PDFViewerApplication.findBar.open();
           handled = true;
         }
@@ -2490,7 +2912,7 @@ function webViewerKeyDown(evt) {
     return;
   }
 
-  const curElement = document.activeElement || document.querySelector(":focus");
+  const curElement = (0, _ui_utils.getActiveOrFocusedElement)();
   const curElementTagName = curElement && curElement.tagName.toUpperCase();
 
   if (curElementTagName === "INPUT" || curElementTagName === "TEXTAREA" || curElementTagName === "SELECT" || curElement && curElement.isContentEditable) {
@@ -2609,13 +3031,9 @@ function webViewerKeyDown(evt) {
 
     if (turnPage !== 0 && (!turnOnlyIfPageFit || pdfViewer.currentScaleValue === "page-fit")) {
       if (turnPage > 0) {
-        if (PDFViewerApplication.page < PDFViewerApplication.pagesCount) {
-          PDFViewerApplication.page++;
-        }
+        pdfViewer.nextPage();
       } else {
-        if (PDFViewerApplication.page > 1) {
-          PDFViewerApplication.page--;
-        }
+        pdfViewer.previousPage();
       }
 
       handled = true;
@@ -2685,22 +3103,22 @@ function apiPageLayoutToSpreadMode(layout) {
 function apiPageModeToSidebarView(mode) {
   switch (mode) {
     case "UseNone":
-      return _pdf_sidebar.SidebarView.NONE;
+      return _ui_utils.SidebarView.NONE;
 
     case "UseThumbs":
-      return _pdf_sidebar.SidebarView.THUMBS;
+      return _ui_utils.SidebarView.THUMBS;
 
     case "UseOutlines":
-      return _pdf_sidebar.SidebarView.OUTLINE;
+      return _ui_utils.SidebarView.OUTLINE;
 
     case "UseAttachments":
-      return _pdf_sidebar.SidebarView.ATTACHMENTS;
+      return _ui_utils.SidebarView.ATTACHMENTS;
 
     case "UseOC":
-      return _pdf_sidebar.SidebarView.LAYERS;
+      return _ui_utils.SidebarView.LAYERS;
   }
 
-  return _pdf_sidebar.SidebarView.NONE;
+  return _ui_utils.SidebarView.NONE;
 }
 
 const PDFPrintServiceFactory = {