@foxycape/core 1.1.3

package/dist/mediaTypes/pdf/renderer/MultiPdfViewer.mjs

@@ -0,0 +1,626 @@
+import * as u from "../../../pdfjs/legacy/build/pdf.mjs";
+import * as a from "../../../pdfjs/legacy/web/pdf_viewer.mjs";
+import { getPageText as h } from "../shared/text/pageText.mjs";
+import { debounce as f } from "perfect-debounce";
+class _ extends a.PDFViewer {
+  constructor(e, i) {
+    super(e), this.options = i, this.#i = null, this.onPageRendered = async () => {
+    }, this.docs = /* @__PURE__ */ new Map(), this.getPageText = async (s, t) => {
+      if (this.otherPages && s > 1) {
+        const r = this._pages.find((n) => n.id == s), o = r.spineFile;
+        if (o) {
+          let n = this.docs.get(r.id), l = !1;
+          n || (n = await this.callback(o, 1), l = !0);
+          const c = await h(n.page, t);
+          if (l) {
+            const d = n.doc;
+            await d.cleanup(!1), d.loadingTask && await d.loadingTask.destroy(), await d.destroy();
+          }
+          return c;
+        }
+        return "";
+      } else {
+        const r = await this.pdfDocument.getPage(s);
+        return await h(r, t);
+      }
+    }, this.forceRenderingQueue = /* @__PURE__ */ new Map(), this.previousPageNumber = 1, this.delayEnsurePdfPageLoaded = f(this.#r, 25), this.loadRemotePdf = async (s) => {
+      const t = this._pages[s - 1];
+      if (t.pdfPage)
+        return t.pdfPage;
+      const r = t.spineFile;
+      if (r) {
+        let o = this.docs.get(s);
+        return o || (o = await this.callback(r, 1), this.docs.set(t.id, o)), o.page;
+      }
+      return null;
+    }, this.DEFAULT_SCALE_DELTA = 1.1, this.MAX_AUTO_SCALE = 1.25, this.MAX_SCALE = 10, this.MIN_SCALE = 0.1, this.#e = null, this.isMultiDocument = !1, this.bindEvents(), this.#i = {
+      previousPageNumber: 1,
+      scrollDown: !0,
+      pages: []
+    };
+  }
+  #i;
+  bindEvents() {
+    this.eventBus.on("pagerendered", this.onPageRendered);
+  }
+  unbindEvents() {
+    this.eventBus.off("pagerendered", this.onPageRendered);
+  }
+  async setOtherPages(e, i) {
+    this.otherPages = e, e && e.length > 0 && (this.isMultiDocument = !0, e.forEach((s) => {
+      s.originDestroy = s.destroy, s.destroy = () => {
+        s.originDestroy(), s.pdfPage = null;
+        const t = this.docs.get(s.id);
+        t && (this.docs.delete(s.id), t.doc.destroy().then(() => {
+          t.doc.cleanup();
+        }));
+      }, this._pages.push(s);
+    })), this.callback = i;
+  }
+  forceRendering(e) {
+    const i = e || this._getVisiblePages(), s = this.#l(i), t = this._spreadMode !== a.SpreadMode.NONE && this._scrollMode !== a.ScrollMode.HORIZONTAL, r = this.renderingQueue.getHighestPriority(i, this._pages, s, t);
+    return r ? (this.previousPageNumber = r.id, this.forceRenderingQueue.get(r.id) ? void 0 : (this.forceRenderingQueue.set(r.id, r.id), this.isMultiDocument ? this.delayEnsurePdfPageLoaded(r).then((o) => {
+      if (this.forceRenderingQueue.delete(r.id), r.pdfPage)
+        this.renderingQueue.renderView(r);
+      else if (o) {
+        const n = this._pages[o.customPageNumber - 1];
+        n.pdfPage || n.setPdfPage(o), this.renderingQueue.renderView(n);
+      }
+    }) : this.#r(r).then((o) => {
+      if (this.forceRenderingQueue.delete(r.id), r.pdfPage)
+        this.renderingQueue.renderView(r);
+      else if (o) {
+        const n = this._pages[o.customPageNumber - 1];
+        n.pdfPage || n.setPdfPage(o), this.renderingQueue.renderView(n);
+      }
+    }), !0)) : !1;
+  }
+  #l(e) {
+    if (e.first?.id === 1)
+      return !0;
+    if (e.last?.id === this.pagesCount)
+      return !1;
+    switch (this._scrollMode) {
+      case a.ScrollMode.PAGE:
+        return this.#i.scrollDown;
+      // return true;
+      case a.ScrollMode.HORIZONTAL:
+        return this.scroll.right;
+    }
+    return this.scroll.down;
+  }
+  async #r(e) {
+    if (e.pdfPage)
+      return e.pdfPage;
+    try {
+      const i = e.spineFile;
+      let s;
+      return i ? s = await this.loadRemotePdf(e.id) : s = await this.pdfDocument.getPage(e.id), s.customPageNumber = e.id, e.pdfPage || e.setPdfPage(s), s;
+    } catch (i) {
+      return console.error("Unable to get page for page view", i), null;
+    }
+  }
+  async dispose() {
+    this.unbindEvents(), this.#e && (clearTimeout(this.#e), this.#e = null);
+    for (const [e, i] of this.docs.entries())
+      try {
+        i.doc && await i.doc.cleanup(), i.doc?.loadingTask && await i.doc.loadingTask.destroy(), i.doc && await i.doc.destroy();
+      } catch {
+      }
+    this.docs.clear(), this.otherPages && this.otherPages.splice(0), this.forceRenderingQueue && this.forceRenderingQueue.clear();
+  }
+  increaseScale({
+    drawingDelay: e,
+    scaleFactor: i,
+    steps: s
+  } = {}) {
+    if (!this.pdfDocument)
+      return;
+    let t = this._currentScale;
+    if (i !== void 0 && i > 1)
+      t = Math.round(t * i * 100) / 100;
+    else {
+      s ??= 1;
+      do
+        t = Math.ceil((t * this.DEFAULT_SCALE_DELTA).toFixed(2) * 10) / 10;
+      while (--s > 0 && t < this.MAX_SCALE);
+    }
+    this.#t(Math.min(this.MAX_SCALE, t), {
+      noScroll: !1,
+      drawingDelay: e
+    });
+  }
+  decreaseScale({
+    drawingDelay: e,
+    scaleFactor: i,
+    steps: s
+  } = {}) {
+    if (!this.pdfDocument)
+      return;
+    let t = this._currentScale;
+    if (i !== void 0 && i > 0 && i < 1)
+      t = Math.round(t * i * 100) / 100;
+    else {
+      s ??= 1;
+      do
+        t = Math.floor((t / this.DEFAULT_SCALE_DELTA).toFixed(2) * 10) / 10;
+      while (--s > 0 && t > this.MIN_SCALE);
+    }
+    this.#t(Math.max(this.MIN_SCALE, t), {
+      noScroll: !1,
+      drawingDelay: e
+    });
+  }
+  _updateScrollMode(e) {
+    const i = this._scrollMode, s = this.viewer;
+    s.classList.toggle("scrollHorizontal", i === a.ScrollMode.HORIZONTAL), s.classList.toggle("scrollWrapped", i === a.ScrollMode.WRAPPED), !(!this.pdfDocument || !e) && (i === a.ScrollMode.PAGE ? this.#s() : this._previousScrollMode === a.ScrollMode.PAGE && this._updateSpreadMode(), this._currentScaleValue && isNaN(this._currentScaleValue) && this.#t(this._currentScaleValue, {
+      noScroll: !0
+    }), this._customSetCurrentPageNumber(
+      e,
+      /* resetCurrentPageView = */
+      !0
+    ), this.update());
+  }
+  _updateSpreadMode(e) {
+    if (!this.pdfDocument)
+      return;
+    const i = this.viewer, s = this._pages;
+    if (this._scrollMode === a.ScrollMode.PAGE)
+      this.#s();
+    else if (i.textContent = "", this._spreadMode === a.SpreadMode.NONE)
+      for (const t of this._pages)
+        i.append(t.div);
+    else {
+      const t = this._spreadMode - 1;
+      let r = null;
+      for (let o = 0, n = s.length; o < n; ++o)
+        r === null ? (r = document.createElement("div"), r.className = "spread", i.append(r)) : o % 2 === t && (r = r.cloneNode(!1), i.append(r)), r.append(s[o].div);
+    }
+    e && (this._currentScaleValue && isNaN(this._currentScaleValue) && this.#t(this._currentScaleValue, {
+      noScroll: !0
+    }), this._customSetCurrentPageNumber(
+      e,
+      /* resetCurrentPageView = */
+      !0
+    ), this.update());
+  }
+  set pagesRotation(e) {
+    if (!this.isValidRotation(e))
+      throw new Error("Invalid pages rotation angle.");
+    if (!this.pdfDocument || (e %= 360, e < 0 && (e += 360), this._pagesRotation === e))
+      return;
+    this._pagesRotation = e;
+    const i = this._currentPageNumber;
+    this.refresh(!0, {
+      rotation: e
+    }), this._currentScaleValue && this.#t(this._currentScaleValue, {
+      noScroll: !0
+    }), this.eventBus.dispatch("rotationchanging", {
+      source: this,
+      pagesRotation: e,
+      pageNumber: i
+    }), this.defaultRenderingQueue && this.update();
+  }
+  get pagesRotation() {
+    return super.pagesRotation;
+  }
+  set currentScaleValue(e) {
+    this.pdfDocument && this.#t(e, {
+      noScroll: !1
+    });
+  }
+  get currentScaleValue() {
+    return super.currentScaleValue;
+  }
+  set currentScale(e) {
+    if (isNaN(e))
+      throw new Error("Invalid numeric scale.");
+    this.pdfDocument && this.#t(e, {
+      noScroll: !1
+    });
+  }
+  get currentScale() {
+    return super.currentScale;
+  }
+  #c(e) {
+    return e === this._currentScale || Math.abs(e - this._currentScale) < 1e-15;
+  }
+  #e;
+  #o(e, i, {
+    noScroll: s = !1,
+    preset: t = !1,
+    drawingDelay: r = -1
+  }) {
+    if (this._currentScaleValue = i.toString(), this.#c(e)) {
+      t && this.eventBus.dispatch("scalechanging", {
+        source: this,
+        scale: e,
+        presetValue: i
+      });
+      return;
+    }
+    this.viewer.style.setProperty("--scale-factor", e * u.PixelsPerInch.PDF_TO_CSS_UNITS);
+    const o = r >= 0 && r < 1e3;
+    if (this.refresh(!0, {
+      scale: e,
+      drawingDelay: o ? r : -1
+    }), o && (this.#e = setTimeout(() => {
+      this.#e = null, this.refresh();
+    }, r)), this._currentScale = e, !s) {
+      let n = this._currentPageNumber, l;
+      this._location && !(this.isInPresentationMode || this.isChangingPresentationMode) && (n = this._location.pageNumber, l = [null, {
+        name: "XYZ"
+      }, this._location.left, this._location.top, null]), this.scrollPageIntoView({
+        pageNumber: n,
+        destArray: l,
+        allowNegativeOffset: !0
+      });
+    }
+    this.eventBus.dispatch("scalechanging", {
+      source: this,
+      scale: e,
+      presetValue: t ? i : void 0
+    }), this.defaultRenderingQueue && this.update();
+  }
+  get #n() {
+    return this._spreadMode !== a.SpreadMode.NONE && this._scrollMode !== a.ScrollMode.HORIZONTAL ? 2 : 1;
+  }
+  #t(e, i) {
+    let s = parseFloat(e);
+    if (typeof e == "string" && e.trim().endsWith("%") && Number.isFinite(s) && s > 0 && (s = s / 100, e = String(s)), s > 0)
+      i.preset = !1, this.#o(s, e, i);
+    else {
+      const t = this._pages[this._currentPageNumber - 1];
+      if (!t)
+        return;
+      let r = this.options.horizontalPadding ? this.options.horizontalPadding : 10, o = this.options.verticalPadding ? this.options.verticalPadding : 0;
+      r < 0 && (r = 0), o < 0 && (o = 0), this._spreadMode !== a.SpreadMode.NONE && (this.options.removeHorizonalMargin || (r += 10)), this.isInPresentationMode ? (r = o = 4, this._spreadMode !== a.SpreadMode.NONE && (r *= 2)) : this.removePageBorders ? this._scrollMode === a.ScrollMode.HORIZONTAL && ([r, o] = [o, r]) : (r += 19 * this.#n, o += 5, this._scrollMode === a.ScrollMode.HORIZONTAL && ([r, o] = [o, r]));
+      const n = (this.container.clientWidth - r) / t.width * t.scale / this.#n, l = (this.container.clientHeight - o) / t.height * t.scale;
+      switch (e) {
+        case "page-actual":
+          s = 1;
+          break;
+        case "page-width":
+          s = n;
+          break;
+        case "page-height":
+          s = l;
+          break;
+        case "page-fit":
+          s = Math.min(n, l);
+          break;
+        case "auto":
+          const c = this.isPortraitOrientation(t) ? n : Math.min(l, n);
+          s = Math.min(this.MAX_AUTO_SCALE, c);
+          break;
+        default:
+          console.error(`#setScale: "${e}" is an unknown zoom value.`);
+          return;
+      }
+      i.preset = !0, this.#o(s, e, i);
+    }
+  }
+  #a() {
+    const e = this._pages[this._currentPageNumber - 1];
+    this.isInPresentationMode && this.#t(this._currentScaleValue, {
+      noScroll: !0
+    }), this.#d(e);
+  }
+  #d(e, i = null) {
+    const {
+      div: s,
+      id: t
+    } = e;
+    if (this._currentPageNumber !== t && this._customSetCurrentPageNumber(t), this._scrollMode === a.ScrollMode.PAGE && (this.#s(), this.update()), !i && !this.isInPresentationMode) {
+      const r = s.offsetLeft + s.clientLeft, o = r + s.clientWidth, {
+        scrollLeft: n,
+        clientWidth: l
+      } = this.container;
+      (this._scrollMode === a.ScrollMode.HORIZONTAL || r < n || o > n + l) && (i = {
+        left: 0,
+        top: 0
+      });
+    }
+    this.scrollIntoView(s, i), !this._currentScaleValue && this._location && (this._location = null);
+  }
+  #s() {
+    if (this._scrollMode !== a.ScrollMode.PAGE)
+      throw new Error("#ensurePageViewVisible: Invalid scrollMode value.");
+    const e = this._currentPageNumber, i = this.#i, s = this.viewer;
+    if (s.textContent = "", i.pages.length = 0, this._spreadMode === a.SpreadMode.NONE && !this.isInPresentationMode) {
+      const t = this._pages[e - 1];
+      s.append(t.div), i.pages.push(t);
+    } else {
+      const t = /* @__PURE__ */ new Set(), r = this._spreadMode - 1;
+      r === -1 ? t.add(e - 1) : e % 2 !== r ? (t.add(e - 1), t.add(e)) : (t.add(e - 2), t.add(e - 1));
+      const o = document.createElement("div");
+      if (o.className = "spread", this.isInPresentationMode) {
+        const n = document.createElement("div");
+        n.className = "dummyPage", o.append(n);
+      }
+      for (const n of t) {
+        const l = this._pages[n];
+        l && (o.append(l.div), i.pages.push(l));
+      }
+      s.append(o);
+    }
+    i.scrollDown = e >= i.previousPageNumber, i.previousPageNumber = e;
+  }
+  rescrollIntoView(e) {
+    this._location = null, this.#t(this._currentScaleValue, {
+      noScroll: !1
+    }), this._customSetCurrentPageNumber(e, !0);
+  }
+  _customSetCurrentPageNumber(e, i = !1) {
+    if (this._currentPageNumber === e)
+      return i && this.#a(), !0;
+    if (!(0 < e && e <= this.pagesCount))
+      return !1;
+    const s = this._currentPageNumber;
+    return this._currentPageNumber = e, this.eventBus.dispatch("pagechanging", {
+      source: this,
+      pageNumber: e,
+      pageLabel: this._pageLabels?.[e - 1] ?? null,
+      previous: s
+    }), i && this.#a(), !0;
+  }
+  scrollIntoView(e, i, s = !1) {
+    let t = e.offsetParent;
+    if (!t) {
+      console.error("offsetParent is not set -- cannot scroll");
+      return;
+    }
+    let r = e.offsetTop + e.clientTop, o = e.offsetLeft + e.clientLeft;
+    for (; t.clientHeight === t.scrollHeight && t.clientWidth === t.scrollWidth || s && (t.classList.contains("markedContent") || getComputedStyle(t).overflow === "hidden"); )
+      if (r += t.offsetTop, o += t.offsetLeft, t = t.offsetParent, !t)
+        return;
+    i && (i.top !== void 0 && (r += i.top), i.left !== void 0 && (o += i.left, t.scrollLeft = o)), t.scrollTop = r;
+  }
+  isPortraitOrientation(e) {
+    return e.width <= e.height;
+  }
+  isValidRotation(e) {
+    return Number.isInteger(e) && e % 90 === 0;
+  }
+  refresh(e = !1, i = /* @__PURE__ */ Object.create(null)) {
+    if (this.pdfDocument) {
+      for (const s of this._pages)
+        s.update(i);
+      this.#e !== null && (clearTimeout(this.#e), this.#e = null), e || this.update();
+    }
+  }
+  // override _getVisiblePages() {
+  //    const views =
+  //       this._scrollMode === pdfjsViewer.ScrollMode.PAGE
+  //          ? this.#scrollModePageState.pages
+  //          : this._pages,
+  //       horizontal = this._scrollMode === pdfjsViewer.ScrollMode.HORIZONTAL,
+  //       rtl = horizontal && this._isContainerRtl;
+  //    this.logger.debug('views', views)
+  //    return this.getVisibleElements({
+  //       scrollEl: this.container,
+  //       views,
+  //       sortByVisibility: true,
+  //       horizontal,
+  //       rtl,
+  //    });
+  // }
+  // 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;
+  //    // 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
+  //    // is itself contained in `view.div` which adds no padding (but does add a
+  //    // border). So, as specified in this function's doc comment, this function
+  //    // does all of its work on the padding edge of the provided views, starting at
+  //    // 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.
+  //    const isElementBottomAfterViewTop = (view) => {
+  //       const element = view.div;
+  //       const elementBottom =
+  //          element.offsetTop + element.clientTop + element.clientHeight;
+  //       return elementBottom > top;
+  //    }
+  //    const 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 = this.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
+  //       // condition: there can be pages with bottoms above the view top between
+  //       // pages with bottoms below. This function detects and corrects that error;
+  //       // see it for more comments.
+  //       firstVisibleElementInd = this.backtrackBeforeAllVisibleElements(
+  //          firstVisibleElementInd,
+  //          views,
+  //          top
+  //       );
+  //    }
+  //    // 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
+  //    // simply stop the first time we reach a page below the bottom of the view;
+  //    // 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;
+  //       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) {
+  //          // As commented above, this is only needed in non-horizontal cases.
+  //          // Setting lastEdge to the bottom of the first page that is partially
+  //          // visible ensures that the next page fully below lastEdge is on the
+  //          // next row, which has to be fully hidden along with all subsequent rows.
+  //          if (viewBottom >= bottom) {
+  //             lastEdge = viewBottom;
+  //          }
+  //       } 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;
+  //       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.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, ids };
+  // }
+  // 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 */
+  // }
+  // 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 ...,
+  //    // true...]. With vertical scrolling and spreads, it is possible to have
+  //    // [false ..., true, false, true ...]. With wrapped scrolling we can have a
+  //    // similar sequence, with many more mixed true and false in the middle.
+  //    //
+  //    // 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.
+  //    //
+  //    //     ****  = fully hidden
+  //    //     A*B*  = mix of partially visible and/or hidden pages
+  //    //     CDEF  = fully visible
+  //    //
+  //    // (1) Binary search could have returned A, in which case we can stop.
+  //    // (2) Binary search could also have returned B, in which case we need to
+  //    // check the whole row.
+  //    // (3) Binary search could also have returned C, in which case we need to
+  //    // check the whole previous row.
+  //    //
+  //    // There's one other possibility:
+  //    //
+  //    //     ****  = fully hidden
+  //    //     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
+  //       // scanning the entire previous row, so we just conservatively assume that
+  //       // we do need to backtrack to that row. In both cases, the previous page is
+  //       // 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
+  //    // `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
+  //    // invisible and we can start looking for potentially visible pages from
+  //    // `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;
+  // }
+}
+export {
+  _ as MultiPDFViewer
+};

package/dist/mediaTypes/pdf/renderer/PdfCoreNavigator.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("../../../kernal/progress/Progress.cjs");class a{constructor(o){this.documentsProvider=o}async goto(o){await this.documentsProvider.load(o)}async gotoUrl(o){const e=new r.FileLocation(o,1,"ratio");e.storeCurrent=!0,await this.goto(e)}async gotoPercentage(o,e){const t=new r.FileLocation(void 0,1,"ratio");t.current=o,t.storeCurrent=!0,t.symbolType=e?.percentageSymbolType??"custom",t.from="drag",await this.goto(t)}}exports.PdfCoreNavigator=a;

package/dist/mediaTypes/pdf/renderer/PdfCoreNavigator.d.ts

@@ -0,0 +1,11 @@
+import { FileLocation, GotoPercentegeOptions, ICoreNavigator, IDocumentsProvider } from '../../../kernal';
+import { IPdfDocument } from './IPdfDocument';
+import { IPdfFileParser } from '../fileParser/IPdfFileParser';
+
+export declare class PdfCoreNavigator implements ICoreNavigator {
+    readonly documentsProvider: IDocumentsProvider<IPdfDocument, IPdfFileParser>;
+    constructor(documentsProvider: IDocumentsProvider<IPdfDocument, IPdfFileParser>);
+    goto(location: FileLocation): Promise<void>;
+    gotoUrl(url: string): Promise<void>;
+    gotoPercentage(percentage: number, options?: GotoPercentegeOptions): Promise<void>;
+}

package/dist/mediaTypes/pdf/renderer/PdfCoreNavigator.mjs

@@ -0,0 +1,20 @@
+import { FileLocation as e } from "../../../kernal/progress/Progress.mjs";
+class n {
+  constructor(o) {
+    this.documentsProvider = o;
+  }
+  async goto(o) {
+    await this.documentsProvider.load(o);
+  }
+  async gotoUrl(o) {
+    const r = new e(o, 1, "ratio");
+    r.storeCurrent = !0, await this.goto(r);
+  }
+  async gotoPercentage(o, r) {
+    const t = new e(void 0, 1, "ratio");
+    t.current = o, t.storeCurrent = !0, t.symbolType = r?.percentageSymbolType ?? "custom", t.from = "drag", await this.goto(t);
+  }
+}
+export {
+  n as PdfCoreNavigator
+};

package/dist/mediaTypes/pdf/renderer/PdfCssVariableNames.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=class t{};t.ContentsContainerWidth="--pdf-contents-container-width",t.ContentsContainerOffsetLeft="--pdf-contents-container-offsetleft",t.ScrollElementOverflow="--pdf-scroll-element-overflow",t.ScrollElementVerticalScrollBarWidth="--pdf-scroll-element-vertial-scrollbar-width",t.ScrollElementHorizontalScrollBarHeight="--pdf-scroll-element-horizontal-scrollbar-height",t.ContentContainerWidth="--pdf-content-container-width",t.ContentWrapperBorderRadius="--pdf-content-wrapper-border-radius";let n=t;exports.PdfCssVariableNames=n;

package/dist/mediaTypes/pdf/renderer/PdfCssVariableNames.d.ts

@@ -0,0 +1,9 @@
+export declare class PdfCssVariableNames {
+    static readonly ContentsContainerWidth = "--pdf-contents-container-width";
+    static readonly ContentsContainerOffsetLeft = "--pdf-contents-container-offsetleft";
+    static readonly ScrollElementOverflow = "--pdf-scroll-element-overflow";
+    static readonly ScrollElementVerticalScrollBarWidth = "--pdf-scroll-element-vertial-scrollbar-width";
+    static readonly ScrollElementHorizontalScrollBarHeight = "--pdf-scroll-element-horizontal-scrollbar-height";
+    static readonly ContentContainerWidth = "--pdf-content-container-width";
+    static readonly ContentWrapperBorderRadius = "--pdf-content-wrapper-border-radius";
+}