art-bd-ui 1.0.21 → 1.0.23

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

@@ -0,0 +1,100 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { useRef, useMemo, useEffect, useCallback } from 'react';
+import mergeRefs from '../../../merge-refs/dist/index.js';
+import { AnnotationMode } from '../../../pdfjs-dist/build/pdf.js';
+import invariant from '../../../tiny-invariant/dist/esm/tiny-invariant.js';
+import warning from '../../../../_virtual/warning.js';
+import StructTree from '../StructTree.js';
+import usePageContext from '../shared/hooks/usePageContext.js';
+import { getDevicePixelRatio, cancelRunningTask, makePageCallback, isAbortException } from '../shared/utils.js';
+
+const ANNOTATION_MODE = AnnotationMode;
+function Canvas(props) {
+    const pageContext = usePageContext();
+    invariant(pageContext, 'Unable to find Page context.');
+    const mergedProps = { ...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 (isAbortException(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: Omitted 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,
+            canvas,
+            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 }));
+}
+
+export { Canvas as default };

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

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

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

@@ -0,0 +1,179 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { useRef, useEffect, useCallback, useMemo, useLayoutEffect } from 'react';
+import { clsx } from '../../../clsx/dist/clsx.js';
+import makeCancellablePromise from '../../../make-cancellable-promise/dist/index.js';
+import { TextLayer as TextLayer$1 } from '../../../pdfjs-dist/build/pdf.js';
+import invariant from '../../../tiny-invariant/dist/esm/tiny-invariant.js';
+import warning from '../../../../_virtual/warning.js';
+import usePageContext from '../shared/hooks/usePageContext.js';
+import useResolver from '../shared/hooks/useResolver.js';
+import { cancelRunningTask, isAbortException } from '../shared/utils.js';
+
+function isTextItem(item) {
+    return 'str' in item;
+}
+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 = makeCancellablePromise(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: Omitted 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) => {
+        if (isAbortException(error)) {
+            return;
+        }
+        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 TextLayer$1(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({
+                        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 (
+    // biome-ignore lint/a11y/noStaticElementInteractions: False positive caused by non interactive wrapper listening for bubbling events
+    jsx("div", { className: clsx('react-pdf__Page__textContent', 'textLayer'), onMouseUp: onMouseUp, onMouseDown: onMouseDown, ref: layerElement }));
+}
+
+export { TextLayer as default };

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

@@ -0,0 +1,252 @@
+"use client";
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { useRef, useMemo, useEffect } from 'react';
+import { clsx } from '../../clsx/dist/clsx.js';
+import makeCancellablePromise from '../../make-cancellable-promise/dist/index.js';
+import makeEventProps from '../../make-event-props/dist/index.js';
+import mergeRefs from '../../merge-refs/dist/index.js';
+import invariant from '../../tiny-invariant/dist/esm/tiny-invariant.js';
+import warning from '../../../_virtual/warning.js';
+import Message from './Message.js';
+import AnnotationLayer from './Page/AnnotationLayer.js';
+import Canvas from './Page/Canvas.js';
+import TextLayer from './Page/TextLayer.js';
+import pageContext from './PageContext.js';
+import useDocumentContext from './shared/hooks/useDocumentContext.js';
+import useResolver from './shared/hooks/useResolver.js';
+import { isProvided, cancelRunningTask, makePageCallback } from './shared/utils.js';
+
+const defaultScale = 1;
+/**
+ * Displays a page.
+ *
+ * Should be placed inside `<Document />`. Alternatively, it can have `pdf` prop passed, which can be obtained from `<Document />`'s `onLoadSuccess` callback function, however some advanced functions like linking between pages inside a document may not be working correctly.
+ */
+function Page(props) {
+    const documentContext = useDocumentContext();
+    const mergedProps = { ...documentContext, ...props };
+    const { _className = 'react-pdf__Page', _enableRegisterUnregisterPage = true, canvasBackground, canvasRef, children, className, customRenderer: CustomRenderer, customTextRenderer, devicePixelRatio, error = 'Failed to load the page.', filterAnnotations, height, inputRef, loading = 'Loading page…', noData = 'No page specified.', onGetAnnotationsError: onGetAnnotationsErrorProps, onGetAnnotationsSuccess: onGetAnnotationsSuccessProps, onGetStructTreeError: onGetStructTreeErrorProps, onGetStructTreeSuccess: onGetStructTreeSuccessProps, onGetTextError: onGetTextErrorProps, onGetTextSuccess: onGetTextSuccessProps, onLoadError: onLoadErrorProps, onLoadSuccess: onLoadSuccessProps, onRenderAnnotationLayerError: onRenderAnnotationLayerErrorProps, onRenderAnnotationLayerSuccess: onRenderAnnotationLayerSuccessProps, onRenderError: onRenderErrorProps, onRenderSuccess: onRenderSuccessProps, onRenderTextLayerError: onRenderTextLayerErrorProps, onRenderTextLayerSuccess: onRenderTextLayerSuccessProps, pageIndex: pageIndexProps, pageNumber: pageNumberProps, pdf, registerPage, renderAnnotationLayer: renderAnnotationLayerProps = true, renderForms = false, renderMode = 'canvas', renderTextLayer: renderTextLayerProps = true, rotate: rotateProps, scale: scaleProps = defaultScale, unregisterPage, width, ...otherProps } = mergedProps;
+    const [pageState, pageDispatch] = useResolver();
+    const { value: page, error: pageError } = pageState;
+    const pageElement = useRef(null);
+    invariant(pdf, 'Attempted to load a page, but no document was specified. Wrap <Page /> in a <Document /> or pass explicit `pdf` prop.');
+    const pageIndex = isProvided(pageNumberProps) ? pageNumberProps - 1 : (pageIndexProps !== null && pageIndexProps !== void 0 ? pageIndexProps : null);
+    const pageNumber = pageNumberProps !== null && pageNumberProps !== void 0 ? pageNumberProps : (isProvided(pageIndexProps) ? pageIndexProps + 1 : null);
+    const rotate = rotateProps !== null && rotateProps !== void 0 ? rotateProps : (page ? page.rotate : null);
+    const scale = useMemo(() => {
+        if (!page) {
+            return null;
+        }
+        // Be default, we'll render page at 100% * scale width.
+        let pageScale = 1;
+        // Passing scale explicitly null would cause the page not to render
+        const scaleWithDefault = scaleProps !== null && scaleProps !== void 0 ? scaleProps : defaultScale;
+        // If width/height is defined, calculate the scale of the page so it could be of desired width.
+        if (width || height) {
+            const viewport = page.getViewport({ scale: 1, rotation: rotate });
+            if (width) {
+                pageScale = width / viewport.width;
+            }
+            else if (height) {
+                pageScale = height / viewport.height;
+            }
+        }
+        return scaleWithDefault * pageScale;
+    }, [height, page, rotate, scaleProps, width]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: useEffect intentionally triggered on pdf change
+    useEffect(function hook() {
+        return () => {
+            if (!isProvided(pageIndex)) {
+                // Impossible, but TypeScript doesn't know that
+                return;
+            }
+            if (_enableRegisterUnregisterPage && unregisterPage) {
+                unregisterPage(pageIndex);
+            }
+        };
+    }, [_enableRegisterUnregisterPage, pdf, pageIndex, unregisterPage]);
+    /**
+     * Called when a page is loaded successfully
+     */
+    function onLoadSuccess() {
+        if (onLoadSuccessProps) {
+            if (!page || !scale) {
+                // Impossible, but TypeScript doesn't know that
+                return;
+            }
+            onLoadSuccessProps(makePageCallback(page, scale));
+        }
+        if (_enableRegisterUnregisterPage && registerPage) {
+            if (!isProvided(pageIndex) || !pageElement.current) {
+                // Impossible, but TypeScript doesn't know that
+                return;
+            }
+            registerPage(pageIndex, pageElement.current);
+        }
+    }
+    /**
+     * Called when a page failed to load
+     */
+    function onLoadError() {
+        if (!pageError) {
+            // Impossible, but TypeScript doesn't know that
+            return;
+        }
+        warning(false, pageError.toString());
+        if (onLoadErrorProps) {
+            onLoadErrorProps(pageError);
+        }
+    }
+    // biome-ignore lint/correctness/useExhaustiveDependencies: useEffect intentionally triggered on pdf and pageIndex change
+    useEffect(function resetPage() {
+        pageDispatch({ type: 'RESET' });
+    }, [pageDispatch, pdf, pageIndex]);
+    useEffect(function loadPage() {
+        if (!pdf || !pageNumber) {
+            return;
+        }
+        const cancellable = makeCancellablePromise(pdf.getPage(pageNumber));
+        const runningTask = cancellable;
+        cancellable.promise
+            .then((nextPage) => {
+            pageDispatch({ type: 'RESOLVE', value: nextPage });
+        })
+            .catch((error) => {
+            pageDispatch({ type: 'REJECT', error });
+        });
+        return () => cancelRunningTask(runningTask);
+    }, [pageDispatch, pdf, pageNumber]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: Omitted callbacks so they are not called every time they change
+    useEffect(() => {
+        if (page === undefined) {
+            return;
+        }
+        if (page === false) {
+            onLoadError();
+            return;
+        }
+        onLoadSuccess();
+    }, [page, scale]);
+    const childContext = useMemo(() => 
+    // Technically there cannot be page without pageIndex, pageNumber, rotate and scale, but TypeScript doesn't know that
+    isProvided(pageIndex) && pageNumber && isProvided(rotate) && isProvided(scale)
+        ? {
+            _className,
+            canvasBackground,
+            customTextRenderer,
+            devicePixelRatio,
+            filterAnnotations,
+            onGetAnnotationsError: onGetAnnotationsErrorProps,
+            onGetAnnotationsSuccess: onGetAnnotationsSuccessProps,
+            onGetStructTreeError: onGetStructTreeErrorProps,
+            onGetStructTreeSuccess: onGetStructTreeSuccessProps,
+            onGetTextError: onGetTextErrorProps,
+            onGetTextSuccess: onGetTextSuccessProps,
+            onRenderAnnotationLayerError: onRenderAnnotationLayerErrorProps,
+            onRenderAnnotationLayerSuccess: onRenderAnnotationLayerSuccessProps,
+            onRenderError: onRenderErrorProps,
+            onRenderSuccess: onRenderSuccessProps,
+            onRenderTextLayerError: onRenderTextLayerErrorProps,
+            onRenderTextLayerSuccess: onRenderTextLayerSuccessProps,
+            page,
+            pageIndex,
+            pageNumber,
+            renderForms,
+            renderTextLayer: renderTextLayerProps,
+            rotate,
+            scale,
+        }
+        : null, [
+        _className,
+        canvasBackground,
+        customTextRenderer,
+        devicePixelRatio,
+        filterAnnotations,
+        onGetAnnotationsErrorProps,
+        onGetAnnotationsSuccessProps,
+        onGetStructTreeErrorProps,
+        onGetStructTreeSuccessProps,
+        onGetTextErrorProps,
+        onGetTextSuccessProps,
+        onRenderAnnotationLayerErrorProps,
+        onRenderAnnotationLayerSuccessProps,
+        onRenderErrorProps,
+        onRenderSuccessProps,
+        onRenderTextLayerErrorProps,
+        onRenderTextLayerSuccessProps,
+        page,
+        pageIndex,
+        pageNumber,
+        renderForms,
+        renderTextLayerProps,
+        rotate,
+        scale,
+    ]);
+    const eventProps = useMemo(() => makeEventProps(otherProps, () => page ? (scale ? makePageCallback(page, scale) : undefined) : page), 
+    // biome-ignore lint/correctness/useExhaustiveDependencies: FIXME
+    [otherProps, page, scale]);
+    const pageKey = `${pageIndex}@${scale}/${rotate}`;
+    function renderMainLayer() {
+        switch (renderMode) {
+            case 'custom': {
+                invariant(CustomRenderer, `renderMode was set to "custom", but no customRenderer was passed.`);
+                return jsx(CustomRenderer, {}, `${pageKey}_custom`);
+            }
+            case 'none':
+                return null;
+            case 'canvas':
+            default:
+                return jsx(Canvas, { canvasRef: canvasRef }, `${pageKey}_canvas`);
+        }
+    }
+    function renderTextLayer() {
+        if (!renderTextLayerProps) {
+            return null;
+        }
+        return jsx(TextLayer, {}, `${pageKey}_text`);
+    }
+    function renderAnnotationLayer() {
+        if (!renderAnnotationLayerProps) {
+            return null;
+        }
+        return jsx(AnnotationLayer, {}, `${pageKey}_annotations`);
+    }
+    function renderChildren() {
+        function isFulfilledContext(context) {
+            return Boolean(context === null || context === void 0 ? void 0 : context.page);
+        }
+        if (!isFulfilledContext(childContext)) {
+            // Impossible, but TypeScript doesn't know that
+            throw new Error('page is undefined');
+        }
+        const resolvedChildren = typeof children === 'function' ? children(childContext) : children;
+        return (jsxs(pageContext.Provider, { value: childContext, children: [renderMainLayer(), renderTextLayer(), renderAnnotationLayer(), resolvedChildren] }));
+    }
+    function renderContent() {
+        if (!pageNumber) {
+            return jsx(Message, { type: "no-data", children: typeof noData === 'function' ? noData() : noData });
+        }
+        if (pdf === null || page === undefined || page === null) {
+            return (jsx(Message, { type: "loading", children: typeof loading === 'function' ? loading() : loading }));
+        }
+        if (pdf === false || page === false) {
+            return jsx(Message, { type: "error", children: typeof error === 'function' ? error() : error });
+        }
+        return renderChildren();
+    }
+    return (jsx("div", { className: clsx(_className, className), "data-page-number": pageNumber, 
+        // Assertion is needed for React 18 compatibility
+        ref: mergeRefs(inputRef, pageElement), style: {
+            '--scale-round-x': '1px',
+            '--scale-round-y': '1px',
+            '--scale-factor': '1',
+            '--user-unit': `${scale}`,
+            '--total-scale-factor': 'calc(var(--scale-factor) * var(--user-unit))',
+            backgroundColor: canvasBackground || 'white',
+            position: 'relative',
+            minWidth: 'min-content',
+            minHeight: 'min-content',
+        }, ...eventProps, children: renderContent() }));
+}
+
+export { Page as default };

package/dist/esm/node_modules/react-pdf/dist/PageContext.js

@@ -0,0 +1,6 @@
+"use client";
+import { createContext } from 'react';
+
+const pageContext = createContext(null);
+
+export { pageContext as default };

package/dist/esm/node_modules/react-pdf/dist/PasswordResponses.js

@@ -0,0 +1,7 @@
+// As defined in https://github.com/mozilla/pdf.js/blob/d9fac3459609a807be6506fb3441b5da4b154d14/src/shared/util.js#L371-L374
+const PasswordResponses = {
+    NEED_PASSWORD: 1,
+    INCORRECT_PASSWORD: 2,
+};
+
+export { PasswordResponses as default };

package/dist/esm/node_modules/react-pdf/dist/StructTree.js

@@ -0,0 +1,77 @@
+import { jsx } from 'react/jsx-runtime';
+import { useEffect } from 'react';
+import makeCancellablePromise from '../../make-cancellable-promise/dist/index.js';
+import invariant from '../../tiny-invariant/dist/esm/tiny-invariant.js';
+import warning from '../../../_virtual/warning.js';
+import StructTreeItem from './StructTreeItem.js';
+import usePageContext from './shared/hooks/usePageContext.js';
+import useResolver from './shared/hooks/useResolver.js';
+import { cancelRunningTask } from './shared/utils.js';
+
+function StructTree() {
+    const pageContext = usePageContext();
+    invariant(pageContext, 'Unable to find Page context.');
+    const { onGetStructTreeError: onGetStructTreeErrorProps, onGetStructTreeSuccess: onGetStructTreeSuccessProps, } = pageContext;
+    const [structTreeState, structTreeDispatch] = useResolver();
+    const { value: structTree, error: structTreeError } = structTreeState;
+    const { customTextRenderer, page } = pageContext;
+    function onLoadSuccess() {
+        if (!structTree) {
+            // Impossible, but TypeScript doesn't know that
+            return;
+        }
+        if (onGetStructTreeSuccessProps) {
+            onGetStructTreeSuccessProps(structTree);
+        }
+    }
+    function onLoadError() {
+        if (!structTreeError) {
+            // Impossible, but TypeScript doesn't know that
+            return;
+        }
+        warning(false, structTreeError.toString());
+        if (onGetStructTreeErrorProps) {
+            onGetStructTreeErrorProps(structTreeError);
+        }
+    }
+    // biome-ignore lint/correctness/useExhaustiveDependencies: useEffect intentionally triggered on page change
+    useEffect(function resetStructTree() {
+        structTreeDispatch({ type: 'RESET' });
+    }, [structTreeDispatch, page]);
+    useEffect(function loadStructTree() {
+        if (customTextRenderer) {
+            // TODO: Document why this is necessary
+            return;
+        }
+        if (!page) {
+            return;
+        }
+        const cancellable = makeCancellablePromise(page.getStructTree());
+        const runningTask = cancellable;
+        cancellable.promise
+            .then((nextStructTree) => {
+            structTreeDispatch({ type: 'RESOLVE', value: nextStructTree });
+        })
+            .catch((error) => {
+            structTreeDispatch({ type: 'REJECT', error });
+        });
+        return () => cancelRunningTask(runningTask);
+    }, [customTextRenderer, page, structTreeDispatch]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: Omitted callbacks so they are not called every time they change
+    useEffect(() => {
+        if (structTree === undefined) {
+            return;
+        }
+        if (structTree === false) {
+            onLoadError();
+            return;
+        }
+        onLoadSuccess();
+    }, [structTree]);
+    if (!structTree) {
+        return null;
+    }
+    return jsx(StructTreeItem, { className: "react-pdf__Page__structTree structTree", node: structTree });
+}
+
+export { StructTree as default };

package/dist/esm/node_modules/react-pdf/dist/StructTreeItem.js

@@ -0,0 +1,23 @@
+import { jsx } from 'react/jsx-runtime';
+import { useMemo } from 'react';
+import { getAttributes, isStructTreeNode, isStructTreeNodeWithOnlyContentChild } from './shared/structTreeUtils.js';
+
+function StructTreeItem({ className, node, }) {
+    const attributes = useMemo(() => getAttributes(node), [node]);
+    const children = useMemo(() => {
+        if (!isStructTreeNode(node)) {
+            return null;
+        }
+        if (isStructTreeNodeWithOnlyContentChild(node)) {
+            return null;
+        }
+        return node.children.map((child, index) => {
+            return (
+            // biome-ignore lint/suspicious/noArrayIndexKey: index is stable here
+            jsx(StructTreeItem, { node: child }, index));
+        });
+    }, [node]);
+    return (jsx("span", { className: className, ...attributes, children: children }));
+}
+
+export { StructTreeItem as default };

package/dist/esm/node_modules/react-pdf/dist/index.js

@@ -0,0 +1,7 @@
+import { GlobalWorkerOptions } from '../../pdfjs-dist/build/pdf.js';
+import * as pdf from '../../pdfjs-dist/build/pdf.js';
+export { pdf as pdfjs };
+import { displayWorkerWarning } from './shared/utils.js';
+
+displayWorkerWarning();
+GlobalWorkerOptions.workerSrc = 'pdf.worker.mjs';