Latest repo

node_modules/react-pdf/dist/esm/Page/AnnotationLayer.css

@@ -0,0 +1,333 @@
+/* Copyright 2014 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+:root {
+  --react-pdf-annotation-layer: 1;
+  --annotation-unfocused-field-background: url("data:image/svg+xml;charset=UTF-8,<svg width='1px' height='1px' xmlns='http://www.w3.org/2000/svg'><rect width='100%' height='100%' style='fill:rgba(0, 54, 255, 0.13);'/></svg>");
+  --input-focus-border-color: Highlight;
+  --input-focus-outline: 1px solid Canvas;
+  --input-unfocused-border-color: transparent;
+  --input-disabled-border-color: transparent;
+  --input-hover-border-color: black;
+  --link-outline: none;
+}
+
+@media screen and (forced-colors: active) {
+  :root {
+    --input-focus-border-color: CanvasText;
+    --input-unfocused-border-color: ActiveText;
+    --input-disabled-border-color: GrayText;
+    --input-hover-border-color: Highlight;
+    --link-outline: 1.5px solid LinkText;
+  }
+  .annotationLayer .textWidgetAnnotation :is(input, textarea):required,
+  .annotationLayer .choiceWidgetAnnotation select:required,
+  .annotationLayer .buttonWidgetAnnotation:is(.checkBox, .radioButton) input:required {
+    outline: 1.5px solid selectedItem;
+  }
+
+  .annotationLayer .linkAnnotation:hover {
+    backdrop-filter: invert(100%);
+  }
+}
+
+.annotationLayer {
+  position: absolute;
+  top: 0;
+  left: 0;
+  pointer-events: none;
+  transform-origin: 0 0;
+  z-index: 3;
+}
+
+.annotationLayer[data-main-rotation='90'] .norotate {
+  transform: rotate(270deg) translateX(-100%);
+}
+.annotationLayer[data-main-rotation='180'] .norotate {
+  transform: rotate(180deg) translate(-100%, -100%);
+}
+.annotationLayer[data-main-rotation='270'] .norotate {
+  transform: rotate(90deg) translateY(-100%);
+}
+
+.annotationLayer canvas {
+  position: absolute;
+  width: 100%;
+  height: 100%;
+}
+
+.annotationLayer section {
+  position: absolute;
+  text-align: initial;
+  pointer-events: auto;
+  box-sizing: border-box;
+  margin: 0;
+  transform-origin: 0 0;
+}
+
+.annotationLayer .linkAnnotation {
+  outline: var(--link-outline);
+}
+
+.textLayer.selecting ~ .annotationLayer section {
+  pointer-events: none;
+}
+
+.annotationLayer :is(.linkAnnotation, .buttonWidgetAnnotation.pushButton) > a {
+  position: absolute;
+  font-size: 1em;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+}
+
+.annotationLayer :is(.linkAnnotation, .buttonWidgetAnnotation.pushButton) > a:hover {
+  opacity: 0.2;
+  background: rgba(255, 255, 0, 1);
+  box-shadow: 0 2px 10px rgba(255, 255, 0, 1);
+}
+
+.annotationLayer .textAnnotation img {
+  position: absolute;
+  cursor: pointer;
+  width: 100%;
+  height: 100%;
+  top: 0;
+  left: 0;
+}
+
+.annotationLayer .textWidgetAnnotation :is(input, textarea),
+.annotationLayer .choiceWidgetAnnotation select,
+.annotationLayer .buttonWidgetAnnotation:is(.checkBox, .radioButton) input {
+  background-image: var(--annotation-unfocused-field-background);
+  border: 2px solid var(--input-unfocused-border-color);
+  box-sizing: border-box;
+  font: calc(9px * var(--scale-factor)) sans-serif;
+  height: 100%;
+  margin: 0;
+  vertical-align: top;
+  width: 100%;
+}
+
+.annotationLayer .textWidgetAnnotation :is(input, textarea):required,
+.annotationLayer .choiceWidgetAnnotation select:required,
+.annotationLayer .buttonWidgetAnnotation:is(.checkBox, .radioButton) input:required {
+  outline: 1.5px solid red;
+}
+
+.annotationLayer .choiceWidgetAnnotation select option {
+  padding: 0;
+}
+
+.annotationLayer .buttonWidgetAnnotation.radioButton input {
+  border-radius: 50%;
+}
+
+.annotationLayer .textWidgetAnnotation textarea {
+  resize: none;
+}
+
+.annotationLayer .textWidgetAnnotation :is(input, textarea)[disabled],
+.annotationLayer .choiceWidgetAnnotation select[disabled],
+.annotationLayer .buttonWidgetAnnotation:is(.checkBox, .radioButton) input[disabled] {
+  background: none;
+  border: 2px solid var(--input-disabled-border-color);
+  cursor: not-allowed;
+}
+
+.annotationLayer .textWidgetAnnotation :is(input, textarea):hover,
+.annotationLayer .choiceWidgetAnnotation select:hover,
+.annotationLayer .buttonWidgetAnnotation:is(.checkBox, .radioButton) input:hover {
+  border: 2px solid var(--input-hover-border-color);
+}
+.annotationLayer .textWidgetAnnotation :is(input, textarea):hover,
+.annotationLayer .choiceWidgetAnnotation select:hover,
+.annotationLayer .buttonWidgetAnnotation.checkBox input:hover {
+  border-radius: 2px;
+}
+
+.annotationLayer .textWidgetAnnotation :is(input, textarea):focus,
+.annotationLayer .choiceWidgetAnnotation select:focus {
+  background: none;
+  border: 2px solid var(--input-focus-border-color);
+  border-radius: 2px;
+  outline: var(--input-focus-outline);
+}
+
+.annotationLayer .buttonWidgetAnnotation:is(.checkBox, .radioButton) :focus {
+  background-image: none;
+  background-color: transparent;
+}
+
+.annotationLayer .buttonWidgetAnnotation.checkBox :focus {
+  border: 2px solid var(--input-focus-border-color);
+  border-radius: 2px;
+  outline: var(--input-focus-outline);
+}
+
+.annotationLayer .buttonWidgetAnnotation.radioButton :focus {
+  border: 2px solid var(--input-focus-border-color);
+  outline: var(--input-focus-outline);
+}
+
+.annotationLayer .buttonWidgetAnnotation.checkBox input:checked::before,
+.annotationLayer .buttonWidgetAnnotation.checkBox input:checked::after,
+.annotationLayer .buttonWidgetAnnotation.radioButton input:checked::before {
+  background-color: CanvasText;
+  content: '';
+  display: block;
+  position: absolute;
+}
+
+.annotationLayer .buttonWidgetAnnotation.checkBox input:checked::before,
+.annotationLayer .buttonWidgetAnnotation.checkBox input:checked::after {
+  height: 80%;
+  left: 45%;
+  width: 1px;
+}
+
+.annotationLayer .buttonWidgetAnnotation.checkBox input:checked::before {
+  transform: rotate(45deg);
+}
+
+.annotationLayer .buttonWidgetAnnotation.checkBox input:checked::after {
+  transform: rotate(-45deg);
+}
+
+.annotationLayer .buttonWidgetAnnotation.radioButton input:checked::before {
+  border-radius: 50%;
+  height: 50%;
+  left: 30%;
+  top: 20%;
+  width: 50%;
+}
+
+.annotationLayer .textWidgetAnnotation input.comb {
+  font-family: monospace;
+  padding-left: 2px;
+  padding-right: 0;
+}
+
+.annotationLayer .textWidgetAnnotation input.comb:focus {
+  /*
+   * Letter spacing is placed on the right side of each character. Hence, the
+   * letter spacing of the last character may be placed outside the visible
+   * area, causing horizontal scrolling. We avoid this by extending the width
+   * when the element has focus and revert this when it loses focus.
+   */
+  width: 103%;
+}
+
+.annotationLayer .buttonWidgetAnnotation:is(.checkBox, .radioButton) input {
+  appearance: none;
+}
+
+.annotationLayer .popupTriggerArea {
+  height: 100%;
+  width: 100%;
+}
+
+.annotationLayer .fileAttachmentAnnotation .popupTriggerArea {
+  position: absolute;
+}
+
+.annotationLayer .popupWrapper {
+  position: absolute;
+  font-size: calc(9px * var(--scale-factor));
+  width: 100%;
+  min-width: calc(180px * var(--scale-factor));
+  pointer-events: none;
+}
+
+.annotationLayer .popup {
+  position: absolute;
+  max-width: calc(180px * var(--scale-factor));
+  background-color: rgba(255, 255, 153, 1);
+  box-shadow: 0 calc(2px * var(--scale-factor)) calc(5px * var(--scale-factor))
+    rgba(136, 136, 136, 1);
+  border-radius: calc(2px * var(--scale-factor));
+  padding: calc(6px * var(--scale-factor));
+  margin-left: calc(5px * var(--scale-factor));
+  cursor: pointer;
+  font: message-box;
+  white-space: normal;
+  word-wrap: break-word;
+  pointer-events: auto;
+}
+
+.annotationLayer .popup > * {
+  font-size: calc(9px * var(--scale-factor));
+}
+
+.annotationLayer .popup h1 {
+  display: inline-block;
+}
+
+.annotationLayer .popupDate {
+  display: inline-block;
+  margin-left: calc(5px * var(--scale-factor));
+}
+
+.annotationLayer .popupContent {
+  border-top: 1px solid rgba(51, 51, 51, 1);
+  margin-top: calc(2px * var(--scale-factor));
+  padding-top: calc(2px * var(--scale-factor));
+}
+
+.annotationLayer .richText > * {
+  white-space: pre-wrap;
+  font-size: calc(9px * var(--scale-factor));
+}
+
+.annotationLayer .highlightAnnotation,
+.annotationLayer .underlineAnnotation,
+.annotationLayer .squigglyAnnotation,
+.annotationLayer .strikeoutAnnotation,
+.annotationLayer .freeTextAnnotation,
+.annotationLayer .lineAnnotation svg line,
+.annotationLayer .squareAnnotation svg rect,
+.annotationLayer .circleAnnotation svg ellipse,
+.annotationLayer .polylineAnnotation svg polyline,
+.annotationLayer .polygonAnnotation svg polygon,
+.annotationLayer .caretAnnotation,
+.annotationLayer .inkAnnotation svg polyline,
+.annotationLayer .stampAnnotation,
+.annotationLayer .fileAttachmentAnnotation {
+  cursor: pointer;
+}
+
+.annotationLayer section svg {
+  position: absolute;
+  width: 100%;
+  height: 100%;
+  top: 0;
+  left: 0;
+}
+
+.annotationLayer .annotationTextContent {
+  position: absolute;
+  width: 100%;
+  height: 100%;
+  opacity: 0;
+  color: transparent;
+  user-select: none;
+  pointer-events: none;
+}
+
+.annotationLayer .annotationTextContent span {
+  width: 100%;
+  display: inline-block;
+}

node_modules/react-pdf/dist/esm/Page/AnnotationLayer.d.ts

@@ -0,0 +1 @@
+export default function AnnotationLayer(): React.ReactElement;

node_modules/react-pdf/dist/esm/Page/AnnotationLayer.js

@@ -0,0 +1,133 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef } from 'react';
+import makeCancellable from 'make-cancellable-promise';
+import clsx from 'clsx';
+import invariant from 'tiny-invariant';
+import warning from 'warning';
+import * as pdfjs from 'pdfjs-dist';
+import useDocumentContext from '../shared/hooks/useDocumentContext.js';
+import usePageContext from '../shared/hooks/usePageContext.js';
+import useResolver from '../shared/hooks/useResolver.js';
+import { cancelRunningTask } from '../shared/utils.js';
+export default function AnnotationLayer() {
+    const documentContext = useDocumentContext();
+    const pageContext = usePageContext();
+    invariant(pageContext, 'Unable to find Page context.');
+    const mergedProps = Object.assign(Object.assign({}, documentContext), pageContext);
+    const { imageResourcesPath, linkService, onGetAnnotationsError: onGetAnnotationsErrorProps, onGetAnnotationsSuccess: onGetAnnotationsSuccessProps, onRenderAnnotationLayerError: onRenderAnnotationLayerErrorProps, onRenderAnnotationLayerSuccess: onRenderAnnotationLayerSuccessProps, page, pdf, renderForms, rotate, scale = 1, } = mergedProps;
+    invariant(pdf, 'Attempted to load page annotations, but no document was specified. Wrap <Page /> in a <Document /> or pass explicit `pdf` prop.');
+    invariant(page, 'Attempted to load page annotations, but no page was specified.');
+    invariant(linkService, 'Attempted to load page annotations, but no linkService was specified.');
+    const [annotationsState, annotationsDispatch] = useResolver();
+    const { value: annotations, error: annotationsError } = annotationsState;
+    const layerElement = useRef(null);
+    warning(Number.parseInt(window.getComputedStyle(document.body).getPropertyValue('--react-pdf-annotation-layer'), 10) === 1, 'AnnotationLayer styles not found. Read more: https://github.com/wojtekmaj/react-pdf#support-for-annotations');
+    function onLoadSuccess() {
+        if (!annotations) {
+            // Impossible, but TypeScript doesn't know that
+            return;
+        }
+        if (onGetAnnotationsSuccessProps) {
+            onGetAnnotationsSuccessProps(annotations);
+        }
+    }
+    function onLoadError() {
+        if (!annotationsError) {
+            // Impossible, but TypeScript doesn't know that
+            return;
+        }
+        warning(false, annotationsError.toString());
+        if (onGetAnnotationsErrorProps) {
+            onGetAnnotationsErrorProps(annotationsError);
+        }
+    }
+    // biome-ignore lint/correctness/useExhaustiveDependencies: useEffect intentionally triggered on page change
+    useEffect(function resetAnnotations() {
+        annotationsDispatch({ type: 'RESET' });
+    }, [annotationsDispatch, page]);
+    useEffect(function loadAnnotations() {
+        if (!page) {
+            return;
+        }
+        const cancellable = makeCancellable(page.getAnnotations());
+        const runningTask = cancellable;
+        cancellable.promise
+            .then((nextAnnotations) => {
+            annotationsDispatch({ type: 'RESOLVE', value: nextAnnotations });
+        })
+            .catch((error) => {
+            annotationsDispatch({ type: 'REJECT', error });
+        });
+        return () => {
+            cancelRunningTask(runningTask);
+        };
+    }, [annotationsDispatch, page]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: Ommitted callbacks so they are not called every time they change
+    useEffect(() => {
+        if (annotations === undefined) {
+            return;
+        }
+        if (annotations === false) {
+            onLoadError();
+            return;
+        }
+        onLoadSuccess();
+    }, [annotations]);
+    function onRenderSuccess() {
+        if (onRenderAnnotationLayerSuccessProps) {
+            onRenderAnnotationLayerSuccessProps();
+        }
+    }
+    function onRenderError(error) {
+        warning(false, `${error}`);
+        if (onRenderAnnotationLayerErrorProps) {
+            onRenderAnnotationLayerErrorProps(error);
+        }
+    }
+    const viewport = useMemo(() => page.getViewport({ scale, rotation: rotate }), [page, rotate, scale]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: Ommitted callbacks so they are not called every time they change
+    useEffect(function renderAnnotationLayer() {
+        if (!pdf || !page || !linkService || !annotations) {
+            return;
+        }
+        const { current: layer } = layerElement;
+        if (!layer) {
+            return;
+        }
+        const clonedViewport = viewport.clone({ dontFlip: true });
+        const annotationLayerParameters = {
+            accessibilityManager: null, // TODO: Implement this
+            annotationCanvasMap: null, // TODO: Implement this
+            annotationEditorUIManager: null, // TODO: Implement this
+            div: layer,
+            l10n: null, // TODO: Implement this
+            page,
+            structTreeLayer: null, // TODO: Implement this
+            viewport: clonedViewport,
+        };
+        const renderParameters = {
+            annotations,
+            annotationStorage: pdf.annotationStorage,
+            div: layer,
+            imageResourcesPath,
+            linkService,
+            page,
+            renderForms,
+            viewport: clonedViewport,
+        };
+        layer.innerHTML = '';
+        try {
+            new pdfjs.AnnotationLayer(annotationLayerParameters).render(renderParameters);
+            // Intentional immediate callback
+            onRenderSuccess();
+        }
+        catch (error) {
+            onRenderError(error);
+        }
+        return () => {
+            // TODO: Cancel running task?
+        };
+    }, [annotations, imageResourcesPath, linkService, page, pdf, renderForms, viewport]);
+    return (_jsx("div", { className: clsx('react-pdf__Page__annotations', 'annotationLayer'), ref: layerElement }));
+}

node_modules/react-pdf/dist/esm/Page/Canvas.d.ts

@@ -0,0 +1,5 @@
+type CanvasProps = {
+    canvasRef?: React.Ref<HTMLCanvasElement>;
+};
+export default function Canvas(props: CanvasProps): React.ReactElement;
+export {};

node_modules/react-pdf/dist/esm/Page/Canvas.js

@@ -0,0 +1,96 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useRef } from 'react';
+import mergeRefs from 'merge-refs';
+import invariant from 'tiny-invariant';
+import warning from 'warning';
+import * as pdfjs from 'pdfjs-dist';
+import StructTree from '../StructTree.js';
+import usePageContext from '../shared/hooks/usePageContext.js';
+import { cancelRunningTask, getDevicePixelRatio, isCancelException, makePageCallback, } from '../shared/utils.js';
+const ANNOTATION_MODE = pdfjs.AnnotationMode;
+export default function Canvas(props) {
+    const pageContext = usePageContext();
+    invariant(pageContext, 'Unable to find Page context.');
+    const mergedProps = Object.assign(Object.assign({}, pageContext), props);
+    const { _className, canvasBackground, devicePixelRatio = getDevicePixelRatio(), onRenderError: onRenderErrorProps, onRenderSuccess: onRenderSuccessProps, page, renderForms, renderTextLayer, rotate, scale, } = mergedProps;
+    const { canvasRef } = props;
+    invariant(page, 'Attempted to render page canvas, but no page was specified.');
+    const canvasElement = useRef(null);
+    /**
+     * Called when a page is rendered successfully.
+     */
+    function onRenderSuccess() {
+        if (!page) {
+            // Impossible, but TypeScript doesn't know that
+            return;
+        }
+        if (onRenderSuccessProps) {
+            onRenderSuccessProps(makePageCallback(page, scale));
+        }
+    }
+    /**
+     * Called when a page fails to render.
+     */
+    function onRenderError(error) {
+        if (isCancelException(error)) {
+            return;
+        }
+        warning(false, error.toString());
+        if (onRenderErrorProps) {
+            onRenderErrorProps(error);
+        }
+    }
+    const renderViewport = useMemo(() => page.getViewport({ scale: scale * devicePixelRatio, rotation: rotate }), [devicePixelRatio, page, rotate, scale]);
+    const viewport = useMemo(() => page.getViewport({ scale, rotation: rotate }), [page, rotate, scale]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: Ommitted callbacks so they are not called every time they change
+    useEffect(function drawPageOnCanvas() {
+        if (!page) {
+            return;
+        }
+        // Ensures the canvas will be re-rendered from scratch. Otherwise all form data will stay.
+        page.cleanup();
+        const { current: canvas } = canvasElement;
+        if (!canvas) {
+            return;
+        }
+        canvas.width = renderViewport.width;
+        canvas.height = renderViewport.height;
+        canvas.style.width = `${Math.floor(viewport.width)}px`;
+        canvas.style.height = `${Math.floor(viewport.height)}px`;
+        canvas.style.visibility = 'hidden';
+        const renderContext = {
+            annotationMode: renderForms ? ANNOTATION_MODE.ENABLE_FORMS : ANNOTATION_MODE.ENABLE,
+            canvasContext: canvas.getContext('2d', { alpha: false }),
+            viewport: renderViewport,
+        };
+        if (canvasBackground) {
+            renderContext.background = canvasBackground;
+        }
+        const cancellable = page.render(renderContext);
+        const runningTask = cancellable;
+        cancellable.promise
+            .then(() => {
+            canvas.style.visibility = '';
+            onRenderSuccess();
+        })
+            .catch(onRenderError);
+        return () => cancelRunningTask(runningTask);
+    }, [canvasBackground, page, renderForms, renderViewport, viewport]);
+    const cleanup = useCallback(() => {
+        const { current: canvas } = canvasElement;
+        /**
+         * Zeroing the width and height cause most browsers to release graphics
+         * resources immediately, which can greatly reduce memory consumption.
+         */
+        if (canvas) {
+            canvas.width = 0;
+            canvas.height = 0;
+        }
+    }, []);
+    useEffect(() => cleanup, [cleanup]);
+    return (_jsx("canvas", { className: `${_className}__canvas`, dir: "ltr", ref: mergeRefs(canvasRef, canvasElement), style: {
+            display: 'block',
+            userSelect: 'none',
+        }, children: renderTextLayer ? _jsx(StructTree, {}) : null }));
+}

node_modules/react-pdf/dist/esm/Page/TextLayer.css

@@ -0,0 +1,119 @@
+/* Copyright 2014 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+:root {
+  --react-pdf-text-layer: 1;
+  --highlight-bg-color: rgba(180, 0, 170, 1);
+  --highlight-selected-bg-color: rgba(0, 100, 0, 1);
+}
+
+@media screen and (forced-colors: active) {
+  :root {
+    --highlight-bg-color: Highlight;
+    --highlight-selected-bg-color: ButtonText;
+  }
+}
+
+[data-main-rotation='90'] {
+  transform: rotate(90deg) translateY(-100%);
+}
+[data-main-rotation='180'] {
+  transform: rotate(180deg) translate(-100%, -100%);
+}
+[data-main-rotation='270'] {
+  transform: rotate(270deg) translateX(-100%);
+}
+
+.textLayer {
+  position: absolute;
+  text-align: initial;
+  inset: 0;
+  overflow: hidden;
+  line-height: 1;
+  text-size-adjust: none;
+  forced-color-adjust: none;
+  transform-origin: 0 0;
+  z-index: 2;
+}
+
+.textLayer :is(span, br) {
+  color: transparent;
+  position: absolute;
+  white-space: pre;
+  cursor: text;
+  margin: 0;
+  transform-origin: 0 0;
+}
+
+/* Only necessary in Google Chrome, see issue 14205, and most unfortunately
+ * the problem doesn't show up in "text" reference tests. */
+.textLayer span.markedContent {
+  top: 0;
+  height: 0;
+}
+
+.textLayer .highlight {
+  margin: -1px;
+  padding: 1px;
+  background-color: var(--highlight-bg-color);
+  border-radius: 4px;
+}
+
+.textLayer .highlight.appended {
+  position: initial;
+}
+
+.textLayer .highlight.begin {
+  border-radius: 4px 0 0 4px;
+}
+
+.textLayer .highlight.end {
+  border-radius: 0 4px 4px 0;
+}
+
+.textLayer .highlight.middle {
+  border-radius: 0;
+}
+
+.textLayer .highlight.selected {
+  background-color: var(--highlight-selected-bg-color);
+}
+
+/* Avoids https://github.com/mozilla/pdf.js/issues/13840 in Chrome */
+.textLayer br::selection {
+  background: transparent;
+}
+
+.textLayer .endOfContent {
+  display: block;
+  position: absolute;
+  inset: 100% 0 0;
+  z-index: -1;
+  cursor: default;
+  user-select: none;
+}
+
+.textLayer.selecting .endOfContent {
+  top: 0;
+}
+
+.hiddenCanvasElement {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 0;
+  height: 0;
+  display: none;
+}

node_modules/react-pdf/dist/esm/Page/TextLayer.d.ts

@@ -0,0 +1 @@
+export default function TextLayer(): React.ReactElement;

node_modules/react-pdf/dist/esm/Page/TextLayer.js

@@ -0,0 +1,168 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef } from 'react';
+import makeCancellable from 'make-cancellable-promise';
+import clsx from 'clsx';
+import invariant from 'tiny-invariant';
+import warning from 'warning';
+import * as pdfjs from 'pdfjs-dist';
+import usePageContext from '../shared/hooks/usePageContext.js';
+import useResolver from '../shared/hooks/useResolver.js';
+import { cancelRunningTask } from '../shared/utils.js';
+function isTextItem(item) {
+    return 'str' in item;
+}
+export default function TextLayer() {
+    const pageContext = usePageContext();
+    invariant(pageContext, 'Unable to find Page context.');
+    const { customTextRenderer, onGetTextError, onGetTextSuccess, onRenderTextLayerError, onRenderTextLayerSuccess, page, pageIndex, pageNumber, rotate, scale, } = pageContext;
+    invariant(page, 'Attempted to load page text content, but no page was specified.');
+    const [textContentState, textContentDispatch] = useResolver();
+    const { value: textContent, error: textContentError } = textContentState;
+    const layerElement = useRef(null);
+    warning(Number.parseInt(window.getComputedStyle(document.body).getPropertyValue('--react-pdf-text-layer'), 10) === 1, 'TextLayer styles not found. Read more: https://github.com/wojtekmaj/react-pdf#support-for-text-layer');
+    /**
+     * Called when a page text content is read successfully
+     */
+    function onLoadSuccess() {
+        if (!textContent) {
+            // Impossible, but TypeScript doesn't know that
+            return;
+        }
+        if (onGetTextSuccess) {
+            onGetTextSuccess(textContent);
+        }
+    }
+    /**
+     * Called when a page text content failed to read successfully
+     */
+    function onLoadError() {
+        if (!textContentError) {
+            // Impossible, but TypeScript doesn't know that
+            return;
+        }
+        warning(false, textContentError.toString());
+        if (onGetTextError) {
+            onGetTextError(textContentError);
+        }
+    }
+    // biome-ignore lint/correctness/useExhaustiveDependencies: useEffect intentionally triggered on page change
+    useEffect(function resetTextContent() {
+        textContentDispatch({ type: 'RESET' });
+    }, [page, textContentDispatch]);
+    useEffect(function loadTextContent() {
+        if (!page) {
+            return;
+        }
+        const cancellable = makeCancellable(page.getTextContent());
+        const runningTask = cancellable;
+        cancellable.promise
+            .then((nextTextContent) => {
+            textContentDispatch({ type: 'RESOLVE', value: nextTextContent });
+        })
+            .catch((error) => {
+            textContentDispatch({ type: 'REJECT', error });
+        });
+        return () => cancelRunningTask(runningTask);
+    }, [page, textContentDispatch]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: Ommitted callbacks so they are not called every time they change
+    useEffect(() => {
+        if (textContent === undefined) {
+            return;
+        }
+        if (textContent === false) {
+            onLoadError();
+            return;
+        }
+        onLoadSuccess();
+    }, [textContent]);
+    /**
+     * Called when a text layer is rendered successfully
+     */
+    const onRenderSuccess = useCallback(() => {
+        if (onRenderTextLayerSuccess) {
+            onRenderTextLayerSuccess();
+        }
+    }, [onRenderTextLayerSuccess]);
+    /**
+     * Called when a text layer failed to render successfully
+     */
+    const onRenderError = useCallback((error) => {
+        warning(false, error.toString());
+        if (onRenderTextLayerError) {
+            onRenderTextLayerError(error);
+        }
+    }, [onRenderTextLayerError]);
+    function onMouseDown() {
+        const layer = layerElement.current;
+        if (!layer) {
+            return;
+        }
+        layer.classList.add('selecting');
+    }
+    function onMouseUp() {
+        const layer = layerElement.current;
+        if (!layer) {
+            return;
+        }
+        layer.classList.remove('selecting');
+    }
+    const viewport = useMemo(() => page.getViewport({ scale, rotation: rotate }), [page, rotate, scale]);
+    useLayoutEffect(function renderTextLayer() {
+        if (!page || !textContent) {
+            return;
+        }
+        const { current: layer } = layerElement;
+        if (!layer) {
+            return;
+        }
+        layer.innerHTML = '';
+        const textContentSource = page.streamTextContent({ includeMarkedContent: true });
+        const parameters = {
+            container: layer,
+            textContentSource,
+            viewport,
+        };
+        const cancellable = new pdfjs.TextLayer(parameters);
+        const runningTask = cancellable;
+        cancellable
+            .render()
+            .then(() => {
+            const end = document.createElement('div');
+            end.className = 'endOfContent';
+            layer.append(end);
+            const layerChildren = layer.querySelectorAll('[role="presentation"]');
+            if (customTextRenderer) {
+                let index = 0;
+                textContent.items.forEach((item, itemIndex) => {
+                    if (!isTextItem(item)) {
+                        return;
+                    }
+                    const child = layerChildren[index];
+                    if (!child) {
+                        return;
+                    }
+                    const content = customTextRenderer(Object.assign({ pageIndex,
+                        pageNumber,
+                        itemIndex }, item));
+                    child.innerHTML = content;
+                    index += item.str && item.hasEOL ? 2 : 1;
+                });
+            }
+            // Intentional immediate callback
+            onRenderSuccess();
+        })
+            .catch(onRenderError);
+        return () => cancelRunningTask(runningTask);
+    }, [
+        customTextRenderer,
+        onRenderError,
+        onRenderSuccess,
+        page,
+        pageIndex,
+        pageNumber,
+        textContent,
+        viewport,
+    ]);
+    return (_jsx("div", { className: clsx('react-pdf__Page__textContent', 'textLayer'), onMouseUp: onMouseUp, onMouseDown: onMouseDown, ref: layerElement }));
+}