@vaadin-component-factory/vcf-pdf-viewer 3.1.0 → 3.2.0

package/pdfjs/dist/ui_utils.js

@@ -12,16 +12,22 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const CSS_UNITS = 96.0 / 72.0;
+
 const DEFAULT_SCALE_VALUE = "auto";
 const DEFAULT_SCALE = 1.0;
+const DEFAULT_SCALE_DELTA = 1.1;
 const MIN_SCALE = 0.1;
 const MAX_SCALE = 10.0;
 const UNKNOWN_SCALE = 0;
 const MAX_AUTO_SCALE = 1.25;
 const SCROLLBAR_PADDING = 40;
 const VERTICAL_PADDING = 5;
-const LOADINGBAR_END_OFFSET_VAR = "--loadingBar-end-offset";
+const RenderingStates = {
+  INITIAL: 0,
+  RUNNING: 1,
+  PAUSED: 2,
+  FINISHED: 3
+};
 const PresentationModeState = {
   UNKNOWN: 0,
   NORMAL: 1,
@@ -37,21 +43,18 @@ const SidebarView = {
   ATTACHMENTS: 3,
   LAYERS: 4
 };
-const RendererType = {
-  CANVAS: "canvas",
-  SVG: "svg"
-};
 const TextLayerMode = {
   DISABLE: 0,
   ENABLE: 1,
-  ENABLE_ENHANCE: 2
+  ENABLE_PERMISSIONS: 2
 };
 const ScrollMode = {
   UNKNOWN: -1,
   VERTICAL: 0,
   // Default value.
   HORIZONTAL: 1,
-  WRAPPED: 2
+  WRAPPED: 2,
+  PAGE: 3
 };
 const SpreadMode = {
   UNKNOWN: -1,
@@ -59,109 +62,112 @@ const SpreadMode = {
   // Default value.
   ODD: 1,
   EVEN: 2
-}; // Used by `PDFViewerApplication`, and by the API unit-tests.
+};
+const CursorTool = {
+  SELECT: 0,
+  // The default value.
+  HAND: 1,
+  ZOOM: 2
+};
 
+// Used by `PDFViewerApplication`, and by the API unit-tests.
 const AutoPrintRegExp = /\bprint\s*\(/;
+
 /**
- * Returns scale factor for the canvas. It makes sense for the HiDPI displays.
- * @returns {Object} The object with horizontal (sx) and vertical (sy)
- *                   scales. The scaled property is set to false if scaling is
- *                   not required, true otherwise.
+ * Scale factors for the canvas, necessary with HiDPI displays.
  */
+class OutputScale {
+  constructor() {
+    const pixelRatio = window.devicePixelRatio || 1;
 
-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
-  };
+    /**
+     * @type {number} Horizontal scale.
+     */
+    this.sx = pixelRatio;
+
+    /**
+     * @type {number} Vertical scale.
+     */
+    this.sy = pixelRatio;
+  }
+
+  /**
+   * @type {boolean} Returns `true` when scaling is required, `false` otherwise.
+   */
+  get scaled() {
+    return this.sx !== 1 || this.sy !== 1;
+  }
 }
+
 /**
  * Scrolls specified element into view of its parent.
- * @param {Object} element - The element to be visible.
- * @param {Object} spot - An object with optional top and left properties,
+ * @param {HTMLElement} element - The element to be visible.
+ * @param {Object} [spot] - An object with optional top and left properties,
  *   specifying the offset from the top left edge.
+ * @param {number} [spot.left]
+ * @param {number} [spot.top]
  * @param {boolean} [scrollMatches] - When scrolling search results into view,
  *   ignore elements that either: Contains marked content identifiers,
  *   or have the CSS-rule `overflow: hidden;` set. The default value is `false`.
  */
-
-
 function scrollIntoView(element, spot, scrollMatches = false) {
   // Assuming offsetParent is available (it's not available when viewer is in
   // hidden iframe or object). We have to scroll: if the offsetParent is not set
   // producing the error. See also animationStarted.
   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; // no need to scroll
     }
   }
-
   if (spot) {
     if (spot.top !== undefined) {
       offsetY += spot.top;
     }
-
     if (spot.left !== undefined) {
       offsetX += spot.left;
       parent.scrollLeft = offsetX;
     }
   }
-
   parent.scrollTop = offsetY;
 }
+
 /**
  * Helper function to start monitoring the scroll event and converting them into
  * PDF.js friendly one: with scroll debounce and scroll direction.
  */
-
-
 function watchScroll(viewAreaElement, callback) {
   const debounceScroll = function (evt) {
     if (rAF) {
       return;
-    } // schedule an invocation of scroll for next animation frame.
-
-
+    }
+    // schedule an invocation of scroll for next animation frame.
     rAF = window.requestAnimationFrame(function viewAreaElementScrolled() {
       rAF = null;
       const currentX = viewAreaElement.scrollLeft;
       const lastX = state.lastX;
-
       if (currentX !== lastX) {
         state.right = currentX > lastX;
       }
-
       state.lastX = currentX;
       const currentY = viewAreaElement.scrollTop;
       const lastY = state.lastY;
-
       if (currentY !== lastY) {
         state.down = currentY > lastY;
       }
-
       state.lastY = currentY;
       callback(state);
     });
   };
-
   const state = {
     right: true,
     down: true,
@@ -173,24 +179,35 @@ function watchScroll(viewAreaElement, callback) {
   viewAreaElement.addEventListener("scroll", debounceScroll, true);
   return state;
 }
+
 /**
- * Helper function to parse query string (e.g. ?param1=value&parm2=...).
+ * Helper function to parse query string (e.g. ?param1=value&param2=...).
+ * @param {string} query
+ * @returns {Map}
  */
-
-
 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);
+  const params = new Map();
+  for (const [key, value] of new URLSearchParams(query)) {
+    params.set(key.toLowerCase(), value);
   }
-
   return params;
 }
+const InvisibleCharsRegExp = /[\x00-\x1F]/g;
+
+/**
+ * @param {string} str
+ * @param {boolean} [replaceInvisible]
+ */
+function removeNullCharacters(str, replaceInvisible = false) {
+  if (!InvisibleCharsRegExp.test(str)) {
+    return str;
+  }
+  if (replaceInvisible) {
+    return str.replaceAll(InvisibleCharsRegExp, m => m === "\x00" ? "" : " ");
+  }
+  return str.replaceAll("\x00", "");
+}
+
 /**
  * Use binary search to find the index of the first item in a given array which
  * passes a given condition. The items are expected to be sorted in the sense
@@ -200,34 +217,27 @@ function parseQueryString(query) {
  * @returns {number} Index of the first array element to pass the test,
  *                   or |items.length| if no such element exists.
  */
-
-
-function binarySearchFirstItem(items, condition) {
-  let minIndex = 0;
+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;
     }
   }
-
-  return minIndex;
-  /* === maxIndex */
+  return minIndex; /* === maxIndex */
 }
+
 /**
  *  Approximates float number as a fraction using Farey sequence (max order
  *  of 8).
@@ -235,39 +245,32 @@ function binarySearchFirstItem(items, condition) {
  *  @returns {Array} Estimated fraction: the first array item is a numerator,
  *                   the second one is a denominator.
  */
-
-
 function approximateFraction(x) {
   // Fast paths for int numbers or their inversions.
   if (Math.floor(x) === x) {
     return [x, 1];
   }
-
   const xinv = 1 / x;
   const limit = 8;
-
   if (xinv > limit) {
     return [1, limit];
   } else if (Math.floor(xinv) === xinv) {
     return [1, xinv];
   }
-
-  const x_ = x > 1 ? xinv : x; // a/b and c/d are neighbours in Farey sequence.
-
+  const x_ = x > 1 ? xinv : x;
+  // a/b and c/d are neighbours in Farey sequence.
   let a = 0,
-      b = 1,
-      c = 1,
-      d = 1; // Limiting search to order 8.
-
+    b = 1,
+    c = 1,
+    d = 1;
+  // Limiting search to order 8.
   while (true) {
     // Generating next term in sequence (order of q).
     const p = a + c,
-          q = b + d;
-
+      q = b + d;
     if (q > limit) {
       break;
     }
-
     if (x_ <= p / q) {
       c = p;
       d = q;
@@ -276,38 +279,45 @@ function approximateFraction(x) {
       b = q;
     }
   }
-
-  let result; // Select closest of the neighbours to x.
-
+  let result;
+  // Select closest of the neighbours to x.
   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);
 }
+
 /**
- * Gets the size of the specified page, converted from PDF units to inches.
- * @param {Object} An Object containing the properties: {Array} `view`,
- *   {number} `userUnit`, and {number} `rotate`.
- * @returns {Object} An Object containing the properties: {number} `width`
- *   and {number} `height`, given in inches.
+ * @typedef {Object} GetPageSizeInchesParameters
+ * @property {number[]} view
+ * @property {number} userUnit
+ * @property {number} rotate
  */
 
+/**
+ * @typedef {Object} PageSize
+ * @property {number} width - In inches.
+ * @property {number} height - In inches.
+ */
 
+/**
+ * Gets the size of the specified page, converted from PDF units to inches.
+ * @param {GetPageSizeInchesParameters} params
+ * @returns {PageSize}
+ */
 function getPageSizeInches({
   view,
   userUnit,
   rotate
 }) {
-  const [x1, y1, x2, y2] = view; // We need to take the page rotation into account as well.
-
+  const [x1, y1, x2, y2] = view;
+  // We need to take the page rotation into account as well.
   const changeOrientation = rotate % 180 !== 0;
   const width = (x2 - x1) / 72 * userUnit;
   const height = (y2 - y1) / 72 * userUnit;
@@ -316,6 +326,7 @@ function getPageSizeInches({
     height: changeOrientation ? width : height
   };
 }
+
 /**
  * Helper function for getVisibleElements.
  *
@@ -327,8 +338,6 @@ function getPageSizeInches({
  *   this will be the first element in the first partially visible row in
  *   `views`, although sometimes it goes back one row further.)
  */
-
-
 function backtrackBeforeAllVisibleElements(index, views, top) {
   // binarySearchFirstItem's assumption is that the input is ordered, with only
   // one index where the conditions flips from false to true: [false ...,
@@ -339,11 +348,14 @@ function backtrackBeforeAllVisibleElements(index, views, top) {
   // So there is no guarantee that the binary search yields the index of the
   // first visible element. It could have been any of the other visible elements
   // that were preceded by a hidden element.
+
   // Of course, if either this element or the previous (hidden) element is also
   // the first element, there's nothing to worry about.
   if (index < 2) {
     return index;
-  } // That aside, the possible cases are represented below.
+  }
+
+  // That aside, the possible cases are represented below.
   //
   //     ****  = fully hidden
   //     A*B*  = mix of partially visible and/or hidden pages
@@ -361,15 +373,13 @@ function backtrackBeforeAllVisibleElements(index, views, top) {
   //     ABCD  = mix of fully and/or partially visible pages
   //
   // (4) Binary search could only have returned A.
+
   // Initially assume that we need to find the beginning of the current row
   // (case 1, 2, or 4), which means finding a page that is above the current
   // page's top. If the found page is partially visible, we're definitely not in
   // case 3, and this assumption is correct.
-
-
   let elt = views[index].div;
   let pageTop = elt.offsetTop + elt.clientTop;
-
   if (pageTop >= top) {
     // The found page is fully visible, so we're actually either in case 3 or 4,
     // and unfortunately we can't tell the difference between them without
@@ -378,7 +388,9 @@ function backtrackBeforeAllVisibleElements(index, views, top) {
     // in the previous row, so use its top instead.
     elt = views[index - 1].div;
     pageTop = elt.offsetTop + elt.clientTop;
-  } // Now we backtrack to the first page that still has its bottom below
+  }
+
+  // Now we backtrack to the first page that still has its bottom below
   // `pageTop`, which is the top of a page in the first visible row (unless
   // we're in case 4, in which case it's the row before that).
   // `index` is found by binary search, so the page at `index - 1` is
@@ -386,23 +398,19 @@ function backtrackBeforeAllVisibleElements(index, views, top) {
   // `index - 2`. (However, if this loop terminates on its first iteration,
   // which is the case when pages are stacked vertically, `index` should remain
   // unchanged, so we use a distinct loop variable.)
-
-
   for (let i = index - 2; i >= 0; --i) {
     elt = views[i].div;
-
     if (elt.offsetTop + elt.clientTop + elt.clientHeight <= pageTop) {
       // We have reached the previous row, so stop now.
       // This loop is expected to terminate relatively quickly because the
       // number of pages per row is expected to be small.
       break;
     }
-
     index = i;
   }
-
   return index;
 }
+
 /**
  * @typedef {Object} GetVisibleElementsParameters
  * @property {HTMLElement} scrollEl - A container that can possibly scroll.
@@ -435,11 +443,9 @@ function backtrackBeforeAllVisibleElements(index, views, top) {
  * rendering canvas. Earlier and later refer to index in `views`, not page
  * layout.)
  *
- * @param {GetVisibleElementsParameters}
+ * @param {GetVisibleElementsParameters} params
  * @returns {Object} `{ first, last, views: [{ id, x, y, view, percent }] }`
  */
-
-
 function getVisibleElements({
   scrollEl,
   views,
@@ -448,9 +454,11 @@ function getVisibleElements({
   rtl = false
 }) {
   const top = scrollEl.scrollTop,
-        bottom = top + scrollEl.clientHeight;
+    bottom = top + scrollEl.clientHeight;
   const left = scrollEl.scrollLeft,
-        right = left + scrollEl.clientWidth; // Throughout this "generic" function, comments will assume we're working with
+    right = left + scrollEl.clientWidth;
+
+  // Throughout this "generic" function, comments will assume we're working with
   // PDF document pages, which is the most important and complex case. In this
   // case, the visible elements we're actually interested is the page canvas,
   // which is contained in a wrapper which adds no padding/border/margin, which
@@ -460,25 +468,24 @@ function getVisibleElements({
   // offsetLeft/Top (which includes margin) and adding clientLeft/Top (which is
   // the border). Adding clientWidth/Height gets us the bottom-right corner of
   // the padding edge.
-
   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 = [],
-        numViews = views.length;
-  let firstVisibleElementInd = binarySearchFirstItem(views, horizontal ? isElementNextAfterViewHorizontally : isElementBottomAfterViewTop); // Please note the return value of the `binarySearchFirstItem` function when
-  // no valid element is found (hence the `firstVisibleElementInd` check below).
+    ids = new Set(),
+    numViews = views.length;
+  let firstVisibleElementInd = binarySearchFirstItem(views, horizontal ? isElementNextAfterViewHorizontally : isElementBottomAfterViewTop);
 
+  // Please note the return value of the `binarySearchFirstItem` function when
+  // no valid element is found (hence the `firstVisibleElementInd` check below).
   if (firstVisibleElementInd > 0 && firstVisibleElementInd < numViews && !horizontal) {
     // In wrapped scrolling (or vertical scrolling with spreads), with some page
     // sizes, isElementBottomAfterViewTop doesn't satisfy the binary search
@@ -486,7 +493,9 @@ function getVisibleElements({
     // pages with bottoms below. This function detects and corrects that error;
     // see it for more comments.
     firstVisibleElementInd = backtrackBeforeAllVisibleElements(firstVisibleElementInd, views, top);
-  } // lastEdge acts as a cutoff for us to stop looping, because we know all
+  }
+
+  // lastEdge acts as a cutoff for us to stop looping, because we know all
   // subsequent pages will be hidden.
   //
   // When using wrapped scrolling or vertical scrolling with spreads, we can't
@@ -494,20 +503,16 @@ function getVisibleElements({
   // the tops of subsequent pages on the same row could still be visible. In
   // horizontal scrolling, we don't have that issue, so we can stop as soon as
   // we pass `right`, without needing the code below that handles the -1 case.
-
-
   let lastEdge = horizontal ? right : -1;
-
   for (let i = firstVisibleElementInd; i < numViews; i++) {
     const view = views[i],
-          element = view.div;
+      element = view.div;
     const currentWidth = element.offsetLeft + element.clientLeft;
     const currentHeight = element.offsetTop + element.clientTop;
     const viewWidth = element.clientWidth,
-          viewHeight = element.clientHeight;
+      viewHeight = element.clientHeight;
     const viewRight = currentWidth + viewWidth;
     const viewBottom = currentHeight + viewHeight;
-
     if (lastEdge === -1) {
       // As commented above, this is only needed in non-horizontal cases.
       // Setting lastEdge to the bottom of the first page that is partially
@@ -519,15 +524,13 @@ function getVisibleElements({
     } else if ((horizontal ? currentWidth : currentHeight) > lastEdge) {
       break;
     }
-
     if (viewBottom <= top || currentHeight >= bottom || viewRight <= left || currentWidth >= right) {
       continue;
     }
-
     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;
+      fractionWidth = (viewWidth - hiddenWidth) / viewWidth;
     const percent = fractionHeight * fractionWidth * 100 | 0;
     visible.push({
       id: view.id,
@@ -537,145 +540,65 @@ function getVisibleElements({
       percent,
       widthPercent: fractionWidth * 100 | 0
     });
+    ids.add(view.id);
   }
-
   const first = visible[0],
-        last = visible[visible.length - 1];
-
+    last = visible.at(-1);
   if (sortByVisibility) {
     visible.sort(function (a, b) {
       const pc = a.percent - b.percent;
-
       if (Math.abs(pc) > 0.001) {
         return -pc;
       }
-
       return a.id - b.id; // ensure stability
     });
   }
-
   return {
     first,
     last,
-    views: visible
+    views: visible,
+    ids
   };
 }
-/**
- * Event handler to suppress context menu.
- */
-
-
-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) {
     // All that is left-up oriented has to change the sign.
     delta = -delta;
   }
-
   return delta;
 }
-
 function normalizeWheelEventDelta(evt) {
+  const deltaMode = evt.deltaMode; // Avoid being affected by bug 1392460.
   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; // Converts delta to per-page units
+  const MOUSE_LINES_PER_PAGE = 30;
 
-  if (evt.deltaMode === MOUSE_DOM_DELTA_PIXEL_MODE) {
+  // Converts delta to per-page units
+  if (deltaMode === WheelEvent.DOM_DELTA_PIXEL) {
     delta /= MOUSE_PIXELS_PER_LINE * MOUSE_LINES_PER_PAGE;
-  } else if (evt.deltaMode === MOUSE_DOM_DELTA_LINE_MODE) {
+  } else if (deltaMode === WheelEvent.DOM_DELTA_LINE) {
     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 WaitOnType = {
-  EVENT: "event",
-  TIMEOUT: "timeout"
-};
-/**
- * @typedef {Object} WaitOnEventOrTimeoutParameters
- * @property {Object} target - The event target, can for example be:
- *   `window`, `document`, a DOM element, or an {EventBus} instance.
- * @property {string} name - The name of the event.
- * @property {number} delay - The delay, in milliseconds, after which the
- *   timeout occurs (if the event wasn't already dispatched).
- */
-
-/**
- * Allows waiting for an event or a timeout, whichever occurs first.
- * Can be used to ensure that an action always occurs, even when an event
- * arrives late or not at all.
- *
- * @param {WaitOnEventOrTimeoutParameters}
- * @returns {Promise} A promise that is resolved with a {WaitOnType} value.
- */
-
-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.");
-    }
-
-    function handler(type) {
-      if (target instanceof EventBus) {
-        target._off(name, eventHandler);
-      } else {
-        target.removeEventListener(name, eventHandler);
-      }
-
-      if (timeout) {
-        clearTimeout(timeout);
-      }
-
-      resolve(type);
-    }
-
-    const eventHandler = handler.bind(null, WaitOnType.EVENT);
-
-    if (target instanceof EventBus) {
-      target._on(name, eventHandler);
-    } else {
-      target.addEventListener(name, eventHandler);
-    }
-
-    const timeoutHandler = handler.bind(null, WaitOnType.TIMEOUT);
-    const timeout = setTimeout(timeoutHandler, delay);
-  });
-}
 /**
  * Promise that is resolved when DOM window becomes visible.
  */
-
-
 const animationStarted = new Promise(function (resolve) {
   if (typeof PDFJSDev !== "undefined" && PDFJSDev.test("LIB") && typeof window === "undefined") {
     // Prevent "ReferenceError: window is not defined" errors when running the
@@ -683,272 +606,73 @@ const animationStarted = new Promise(function (resolve) {
     setTimeout(resolve, 20);
     return;
   }
-
   window.requestAnimationFrame(resolve);
 });
-/**
- * NOTE: Only used to support various PDF viewer tests in `mozilla-central`.
- */
-
-function dispatchDOMEvent(eventName, args = null) {
-  if (typeof PDFJSDev !== "undefined" && !PDFJSDev.test("MOZCENTRAL")) {
-    throw new Error("Not implemented: dispatchDOMEvent");
-  }
-
-  const details = Object.create(null);
-
-  if ((args === null || args === void 0 ? void 0 : args.length) > 0) {
-    const obj = args[0];
-
-    for (const key in obj) {
-      const value = obj[key];
-
-      if (key === "source") {
-        if (value === window || value === document) {
-          return; // No need to re-dispatch (already) global events.
-        }
-
-        continue; // Ignore the `source` property.
-      }
-
-      details[key] = value;
-    }
-  }
-
-  const event = document.createEvent("CustomEvent");
-  event.initCustomEvent(eventName, true, true, details);
-  document.dispatchEvent(event);
-}
-/**
- * Simple event bus for an application. Listeners are attached using the `on`
- * and `off` methods. To raise an event, the `dispatch` method shall be used.
- */
-
-
-class EventBus {
-  constructor(options) {
-    this._listeners = Object.create(null);
-
-    if (typeof PDFJSDev === "undefined" || PDFJSDev.test("MOZCENTRAL")) {
-      this._isInAutomation = (options === null || options === void 0 ? void 0 : options.isInAutomation) === true;
-    }
-  }
-  /**
-   * @param {string} eventName
-   * @param {function} listener
-   * @param {Object} [options]
-   */
-
-
-  on(eventName, listener, options = null) {
-    this._on(eventName, listener, {
-      external: true,
-      once: options === null || options === void 0 ? void 0 : options.once
-    });
-  }
-  /**
-   * @param {string} eventName
-   * @param {function} listener
-   * @param {Object} [options]
-   */
-
-
-  off(eventName, listener, options = null) {
-    this._off(eventName, listener, {
-      external: true,
-      once: options === null || options === void 0 ? void 0 : options.once
-    });
-  }
-
-  dispatch(eventName) {
-    const eventListeners = this._listeners[eventName];
-
-    if (!eventListeners || eventListeners.length === 0) {
-      if ((typeof PDFJSDev === "undefined" || PDFJSDev.test("MOZCENTRAL")) && this._isInAutomation) {
-        const args = Array.prototype.slice.call(arguments, 1);
-        dispatchDOMEvent(eventName, args);
-      }
-
-      return;
-    } // Passing all arguments after the eventName to the listeners.
-
-
-    const args = Array.prototype.slice.call(arguments, 1);
-    let externalListeners; // Making copy of the listeners array in case if it will be modified
-    // during dispatch.
-
-    for (const {
-      listener,
-      external,
-      once
-    } of eventListeners.slice(0)) {
-      if (once) {
-        this._off(eventName, listener);
-      }
-
-      if (external) {
-        (externalListeners || (externalListeners = [])).push(listener);
-        continue;
-      }
-
-      listener.apply(null, args);
-    } // Dispatch any "external" listeners *after* the internal ones, to give the
-    // viewer components time to handle events and update their state first.
-
-
-    if (externalListeners) {
-      for (const listener of externalListeners) {
-        listener.apply(null, args);
-      }
-
-      externalListeners = null;
-    }
-
-    if ((typeof PDFJSDev === "undefined" || PDFJSDev.test("MOZCENTRAL")) && this._isInAutomation) {
-      dispatchDOMEvent(eventName, args);
-    }
-  }
-  /**
-   * @ignore
-   */
-
-
-  _on(eventName, listener, options = null) {
-    var _this$_listeners;
-
-    const eventListeners = (_this$_listeners = this._listeners)[eventName] || (_this$_listeners[eventName] = []);
-    eventListeners.push({
-      listener,
-      external: (options === null || options === void 0 ? void 0 : options.external) === true,
-      once: (options === null || options === void 0 ? void 0 : options.once) === true
-    });
-  }
-  /**
-   * @ignore
-   */
-
-
-  _off(eventName, listener, options = null) {
-    const eventListeners = this._listeners[eventName];
-
-    if (!eventListeners) {
-      return;
-    }
-
-    for (let i = 0, ii = eventListeners.length; i < ii; i++) {
-      if (eventListeners[i].listener === listener) {
-        eventListeners.splice(i, 1);
-        return;
-      }
-    }
-  }
-
-}
-
+const docStyle = typeof PDFJSDev !== "undefined" && PDFJSDev.test("LIB") && typeof document === "undefined" ? null : document.documentElement.style;
 function clamp(v, min, max) {
   return Math.min(Math.max(v, min), max);
 }
-
 class ProgressBar {
-  constructor(id, {
-    height,
-    width,
-    units
-  } = {}) {
-    this.visible = true; // Fetch the sub-elements for later.
-
-    this.div = document.querySelector(id + " .progress"); // Get the loading bar element, so it can be resized to fit the viewer.
-
-    this.bar = this.div.parentNode; // Get options, with sensible defaults.
-
-    this.height = height || 100;
-    this.width = width || 100;
-    this.units = units || "%"; // Initialize heights.
-
-    this.div.style.height = this.height + this.units;
-    this.percent = 0;
+  #classList = null;
+  #disableAutoFetchTimeout = null;
+  #percent = 0;
+  #style = null;
+  #visible = true;
+  constructor(bar) {
+    this.#classList = bar.classList;
+    this.#style = bar.style;
   }
-
-  _updateBar() {
-    if (this._indeterminate) {
-      this.div.classList.add("indeterminate");
-      this.div.style.width = this.width + this.units;
-      return;
-    }
-
-    this.div.classList.remove("indeterminate");
-    const progressSize = this.width * this._percent / 100;
-    this.div.style.width = progressSize + this.units;
-  }
-
   get percent() {
-    return this._percent;
+    return this.#percent;
   }
-
   set percent(val) {
-    this._indeterminate = isNaN(val);
-    this._percent = clamp(val, 0, 100);
-
-    this._updateBar();
+    this.#percent = clamp(val, 0, 100);
+    if (isNaN(val)) {
+      this.#classList.add("indeterminate");
+      return;
+    }
+    this.#classList.remove("indeterminate");
+    this.#style.setProperty("--progressBar-percent", `${this.#percent}%`);
   }
-
   setWidth(viewer) {
     if (!viewer) {
       return;
     }
-
     const container = viewer.parentNode;
     const scrollbarWidth = container.offsetWidth - viewer.offsetWidth;
-
     if (scrollbarWidth > 0) {
-      const doc = document.documentElement;
-      doc.style.setProperty(LOADINGBAR_END_OFFSET_VAR, `${scrollbarWidth}px`);
+      this.#style.setProperty("--progressBar-end-offset", `${scrollbarWidth}px`);
     }
   }
-
+  setDisableAutoFetch(delay = /* ms = */5000) {
+    if (isNaN(this.#percent)) {
+      return;
+    }
+    if (this.#disableAutoFetchTimeout) {
+      clearTimeout(this.#disableAutoFetchTimeout);
+    }
+    this.show();
+    this.#disableAutoFetchTimeout = setTimeout(() => {
+      this.#disableAutoFetchTimeout = null;
+      this.hide();
+    }, delay);
+  }
   hide() {
-    if (!this.visible) {
+    if (!this.#visible) {
       return;
     }
-
-    this.visible = false;
-    this.bar.classList.add("hidden");
+    this.#visible = false;
+    this.#classList.add("hidden");
   }
-
   show() {
-    if (this.visible) {
+    if (this.#visible) {
       return;
     }
-
-    this.visible = true;
-    this.bar.classList.remove("hidden");
+    this.#visible = true;
+    this.#classList.remove("hidden");
   }
-
 }
-/**
- * Moves all elements of an array that satisfy condition to the end of the
- * array, preserving the order of the rest.
- */
-
-
-function moveToEndOfArray(arr, condition) {
-  const moved = [],
-        len = arr.length;
-  let write = 0;
 
-  for (let read = 0; read < len; ++read) {
-    if (condition(arr[read])) {
-      moved.push(arr[read]);
-    } else {
-      arr[write] = arr[read];
-      ++write;
-    }
-  }
-
-  for (let read = 0; write < len; ++read, ++write) {
-    arr[write] = moved[read];
-  }
-}
 /**
  * Get the active or focused element in current DOM.
  *
@@ -957,48 +681,50 @@ function moveToEndOfArray(arr, condition) {
  *
  * @returns {Element} the truly active or focused element.
  */
-
-
 function getActiveOrFocusedElement() {
   let curRoot = document;
   let curActiveOrFocused = curRoot.activeElement || curRoot.querySelector(":focus");
-
   while ((_curActiveOrFocused = curActiveOrFocused) !== null && _curActiveOrFocused !== void 0 && _curActiveOrFocused.shadowRoot) {
     var _curActiveOrFocused;
-
     curRoot = curActiveOrFocused.shadowRoot;
     curActiveOrFocused = curRoot.activeElement || curRoot.querySelector(":focus");
   }
-
   return curActiveOrFocused;
 }
+
 /**
  * Converts API PageLayout values to the format used by `BaseViewer`.
- * NOTE: This is supported to the extent that the viewer implements the
- *       necessary Scroll/Spread modes (since SinglePage, TwoPageLeft,
- *       and TwoPageRight all suggests using non-continuous scrolling).
- * @param {string} mode - The API PageLayout value.
- * @returns {number} A value from {SpreadMode}.
+ * @param {string} layout - The API PageLayout value.
+ * @returns {Object}
  */
-
-
-function apiPageLayoutToSpreadMode(layout) {
+function apiPageLayoutToViewerModes(layout) {
+  let scrollMode = ScrollMode.VERTICAL,
+    spreadMode = SpreadMode.NONE;
   switch (layout) {
     case "SinglePage":
+      scrollMode = ScrollMode.PAGE;
+      break;
     case "OneColumn":
-      return SpreadMode.NONE;
-
-    case "TwoColumnLeft":
+      break;
     case "TwoPageLeft":
-      return SpreadMode.ODD;
-
-    case "TwoColumnRight":
+      scrollMode = ScrollMode.PAGE;
+    /* falls through */
+    case "TwoColumnLeft":
+      spreadMode = SpreadMode.ODD;
+      break;
     case "TwoPageRight":
-      return SpreadMode.EVEN;
+      scrollMode = ScrollMode.PAGE;
+    /* falls through */
+    case "TwoColumnRight":
+      spreadMode = SpreadMode.EVEN;
+      break;
   }
-
-  return SpreadMode.NONE; // Default value.
+  return {
+    scrollMode,
+    spreadMode
+  };
 }
+
 /**
  * Converts API PageMode values to the format used by `PDFSidebar`.
  * NOTE: There's also a "FullScreen" parameter which is not possible to support,
@@ -1007,27 +733,30 @@ function apiPageLayoutToSpreadMode(layout) {
  * @param {string} mode - The API PageMode value.
  * @returns {number} A value from {SidebarView}.
  */
-
-
 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; // Default value.
 }
+function toggleCheckedBtn(button, toggle, view = null) {
+  button.classList.toggle("toggled", toggle);
+  button.setAttribute("aria-checked", toggle);
+  view === null || view === void 0 ? void 0 : view.classList.toggle("hidden", !toggle);
+}
+function toggleExpandedBtn(button, toggle, view = null) {
+  button.classList.toggle("toggled", toggle);
+  button.setAttribute("aria-expanded", toggle);
+  view === null || view === void 0 ? void 0 : view.classList.toggle("hidden", !toggle);
+}
 
-export { AutoPrintRegExp, CSS_UNITS, DEFAULT_SCALE, DEFAULT_SCALE_VALUE, EventBus, MAX_AUTO_SCALE, MAX_SCALE, MIN_SCALE, PresentationModeState, ProgressBar, RendererType, SCROLLBAR_PADDING, ScrollMode, SidebarView, SpreadMode, TextLayerMode, UNKNOWN_SCALE, VERTICAL_PADDING, WaitOnType, animationStarted, apiPageLayoutToSpreadMode, apiPageModeToSidebarView, approximateFraction, backtrackBeforeAllVisibleElements, binarySearchFirstItem, getActiveOrFocusedElement, getOutputScale, getPageSizeInches, getVisibleElements, isPortraitOrientation, isValidRotation, isValidScrollMode, isValidSpreadMode, moveToEndOfArray, noContextMenuHandler, normalizeWheelEventDelta, normalizeWheelEventDirection, parseQueryString, roundToDivide, scrollIntoView, waitOnEventOrTimeout, watchScroll };
+export { AutoPrintRegExp, CursorTool, DEFAULT_SCALE, DEFAULT_SCALE_DELTA, DEFAULT_SCALE_VALUE, MAX_AUTO_SCALE, MAX_SCALE, MIN_SCALE, OutputScale, PresentationModeState, ProgressBar, RenderingStates, SCROLLBAR_PADDING, ScrollMode, SidebarView, SpreadMode, TextLayerMode, UNKNOWN_SCALE, VERTICAL_PADDING, animationStarted, apiPageLayoutToViewerModes, apiPageModeToSidebarView, approximateFraction, backtrackBeforeAllVisibleElements, binarySearchFirstItem, docStyle, getActiveOrFocusedElement, getPageSizeInches, getVisibleElements, isPortraitOrientation, isValidRotation, isValidScrollMode, isValidSpreadMode, normalizeWheelEventDelta, normalizeWheelEventDirection, parseQueryString, removeNullCharacters, roundToDivide, scrollIntoView, toggleCheckedBtn, toggleExpandedBtn, watchScroll };