@a3s-lab/office 0.1.0

package/dist/0~pdf-viewer.js

@@ -0,0 +1,2156 @@
+import { __webpack_require__ } from "./0~rslib-runtime.js";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { AnnotationPlugin, DocumentManagerPlugin, ExportPlugin, HistoryPlugin, PDFViewer, ScrollPlugin, SearchPlugin, ThumbnailPlugin, ZoomMode, ZoomPlugin } from "@embedpdf/react-pdf-viewer";
+import { AlertCircle, Check, ChevronDown, ChevronLeft, ChevronRight, ChevronUp, Ellipsis, GalleryVerticalEnd, Highlighter, Loader2, Minus, MousePointer2, MoveHorizontal, Pencil, Plus, Redo2, Save, Scan, Search, SlidersHorizontal, Strikethrough, Trash2, Type, Underline, Undo2, X } from "lucide-react";
+import { useCallback, useEffect, useId, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { createOfficeEditorExtension, useOfficeEditorRuntime, useOfficeEditorKeyboardShortcuts } from "./0~3557.js";
+import { isOfficeShortcutBlocked, OfficeColorPicker } from "./0~3635.js";
+import { button_Button, moveOfficeMenuFocus, icon_button_IconButton, office_text_field_OfficeTextField, Popover, useDialogFocusScope, useOfficeEditorWheelZoom } from "./0~9512.js";
+import { StateView } from "./432.js";
+var pdf_viewer_namespaceObject = {};
+__webpack_require__.r(pdf_viewer_namespaceObject);
+__webpack_require__.d(pdf_viewer_namespaceObject, {
+    PdfViewer: ()=>PdfViewer,
+    a3sPdfUiSchema: ()=>a3sPdfUiSchema
+});
+const INITIAL_STATE = {
+    activeToolId: null,
+    annotationColor: '#ffd966',
+    annotationOpacity: 1,
+    annotationStrokeWidth: 6,
+    available: false,
+    availableToolIds: [],
+    hasPendingChanges: false,
+    selectedCount: 0,
+    supportsOpacity: false,
+    supportsStrokeWidth: false
+};
+function usePdfAnnotationController(registry) {
+    const capabilitiesRef = useRef(null);
+    const [state, setState] = useState(INITIAL_STATE);
+    useEffect(()=>{
+        let disposed = false;
+        const unsubscribe = [];
+        capabilitiesRef.current = null;
+        setState(INITIAL_STATE);
+        if (!registry) return;
+        registry.pluginsReady().then(()=>{
+            if (disposed) return;
+            const capabilities = {
+                annotation: registry.getPlugin(AnnotationPlugin.id)?.provides() ?? null,
+                documentManager: registry.getPlugin(DocumentManagerPlugin.id)?.provides() ?? null
+            };
+            capabilitiesRef.current = capabilities;
+            const sync = ()=>{
+                if (disposed) return;
+                const scope = activeAnnotationScope(capabilities);
+                const annotationState = safely(()=>scope?.getState());
+                const activeToolId = annotationState?.activeToolId ?? null;
+                const style = currentAnnotationStyle(capabilities, scope, activeToolId);
+                setState({
+                    activeToolId,
+                    annotationColor: currentAnnotationColor(capabilities, scope, activeToolId),
+                    ...style,
+                    available: Boolean(scope),
+                    availableToolIds: availableAnnotationToolIds(capabilities),
+                    hasPendingChanges: annotationState?.hasPendingChanges ?? false,
+                    selectedCount: annotationState?.selectedUids.length ?? 0
+                });
+            };
+            subscribe(unsubscribe, capabilities.annotation?.onStateChange, sync);
+            subscribe(unsubscribe, capabilities.annotation?.onActiveToolChange, sync);
+            subscribe(unsubscribe, capabilities.documentManager?.onActiveDocumentChanged, sync);
+            subscribe(unsubscribe, capabilities.documentManager?.onDocumentOpened, sync);
+            subscribe(unsubscribe, capabilities.documentManager?.onDocumentClosed, sync);
+            sync();
+        }).catch(()=>{
+            if (!disposed) setState(INITIAL_STATE);
+        });
+        return ()=>{
+            disposed = true;
+            capabilitiesRef.current = null;
+            for (const stop of unsubscribe)stop();
+        };
+    }, [
+        registry
+    ]);
+    const selectTool = useCallback((toolId)=>{
+        const capabilities = capabilitiesRef.current;
+        const scope = activeAnnotationScope(capabilities);
+        if (!scope) return;
+        if (toolId && !capabilities?.annotation?.getTool(toolId)) return;
+        safely(()=>scope.setActiveTool(toolId));
+    }, []);
+    const deleteSelection = useCallback(()=>{
+        const scope = activeAnnotationScope(capabilitiesRef.current);
+        if (!scope) return;
+        const selected = new Set(scope.getSelectedAnnotationIds());
+        if (0 === selected.size) return;
+        const deletions = Object.entries(scope.getState().pages).flatMap(([pageIndex, annotationIds])=>annotationIds.filter((annotationId)=>selected.has(annotationId)).map((annotationId)=>({
+                    pageIndex: Number(pageIndex),
+                    id: annotationId
+                })));
+        if (deletions.length > 0) scope.deleteAnnotations(deletions);
+    }, []);
+    const setAnnotationColor = useCallback((color)=>{
+        const normalizedColor = normalizeAnnotationColor(color);
+        const capabilities = capabilitiesRef.current;
+        const scope = activeAnnotationScope(capabilities);
+        if (!normalizedColor || !capabilities?.annotation || !scope) return;
+        const activeToolId = scope.getState().activeToolId;
+        const patch = {
+            color: normalizedColor,
+            strokeColor: normalizedColor
+        };
+        if (activeToolId) capabilities.annotation.setToolDefaults(activeToolId, patch);
+        const selected = scope.getSelectedAnnotations();
+        if (selected.length) scope.updateAnnotations(selected.map(({ object })=>({
+                pageIndex: object.pageIndex,
+                id: object.id,
+                patch
+            })));
+        setState((current)=>({
+                ...current,
+                annotationColor: normalizedColor
+            }));
+    }, []);
+    const setAnnotationOpacity = useCallback((opacity)=>{
+        const normalizedOpacity = normalizeAnnotationOpacity(opacity);
+        if (null === normalizedOpacity || !applyAnnotationNumberStyle(capabilitiesRef.current, 'opacity', normalizedOpacity)) return;
+        setState((current)=>({
+                ...current,
+                annotationOpacity: normalizedOpacity
+            }));
+    }, []);
+    const setAnnotationStrokeWidth = useCallback((strokeWidth)=>{
+        const normalizedStrokeWidth = normalizeAnnotationStrokeWidth(strokeWidth);
+        if (null === normalizedStrokeWidth || !applyAnnotationNumberStyle(capabilitiesRef.current, 'strokeWidth', normalizedStrokeWidth)) return;
+        setState((current)=>({
+                ...current,
+                annotationStrokeWidth: normalizedStrokeWidth
+            }));
+    }, []);
+    return useMemo(()=>({
+            state,
+            deleteSelection,
+            setAnnotationColor,
+            setAnnotationOpacity,
+            setAnnotationStrokeWidth,
+            selectTool
+        }), [
+        deleteSelection,
+        setAnnotationColor,
+        setAnnotationOpacity,
+        setAnnotationStrokeWidth,
+        selectTool,
+        state
+    ]);
+}
+const PDF_ANNOTATION_TOOL_IDS = [
+    'highlight',
+    'underline',
+    'strikeout',
+    'ink',
+    'freeText'
+];
+function availableAnnotationToolIds(capabilities) {
+    return PDF_ANNOTATION_TOOL_IDS.filter((toolId)=>Boolean(safely(()=>capabilities.annotation?.getTool(toolId))));
+}
+function currentAnnotationStyle(capabilities, scope, activeToolId) {
+    const selectedObjects = safely(()=>scope?.getSelectedAnnotations().map(({ object })=>object)) ?? [];
+    const activeDefaults = activeToolId ? safely(()=>capabilities.annotation?.getTool(activeToolId)?.defaults) : null;
+    const opacitySource = selectedObjects.find((object)=>annotationRecordSupports(object, 'opacity')) ?? activeDefaults;
+    const strokeWidthSource = selectedObjects.find((object)=>annotationRecordSupports(object, 'strokeWidth')) ?? activeDefaults;
+    return {
+        annotationOpacity: annotationNumberFromRecord(opacitySource, 'opacity', normalizeAnnotationOpacity) ?? INITIAL_STATE.annotationOpacity,
+        annotationStrokeWidth: annotationNumberFromRecord(strokeWidthSource, 'strokeWidth', normalizeAnnotationStrokeWidth) ?? INITIAL_STATE.annotationStrokeWidth,
+        supportsOpacity: selectedObjects.some((object)=>annotationRecordSupports(object, 'opacity')) || annotationRecordSupports(activeDefaults, 'opacity'),
+        supportsStrokeWidth: selectedObjects.some((object)=>annotationRecordSupports(object, 'strokeWidth')) || annotationRecordSupports(activeDefaults, 'strokeWidth')
+    };
+}
+function applyAnnotationNumberStyle(capabilities, attribute, value) {
+    const scope = activeAnnotationScope(capabilities);
+    if (!capabilities?.annotation || !scope) return false;
+    const patch = {
+        [attribute]: value
+    };
+    const activeToolId = scope.getState().activeToolId;
+    const activeDefaults = activeToolId ? safely(()=>capabilities.annotation?.getTool(activeToolId)?.defaults) : null;
+    let applied = false;
+    if (activeToolId && annotationRecordSupports(activeDefaults, attribute)) {
+        capabilities.annotation.setToolDefaults(activeToolId, patch);
+        applied = true;
+    }
+    const selected = scope.getSelectedAnnotations().filter(({ object })=>annotationRecordSupports(object, attribute));
+    if (selected.length) {
+        scope.updateAnnotations(selected.map(({ object })=>({
+                pageIndex: object.pageIndex,
+                id: object.id,
+                patch
+            })));
+        applied = true;
+    }
+    return applied;
+}
+function currentAnnotationColor(capabilities, scope, activeToolId) {
+    const selectedObject = safely(()=>scope?.getSelectedAnnotations()[0]?.object);
+    const selectedColor = annotationColorFromRecord(selectedObject);
+    if (selectedColor) return selectedColor;
+    const activeTool = activeToolId ? safely(()=>capabilities.annotation?.getTool(activeToolId)) : null;
+    return annotationColorFromRecord(activeTool?.defaults) ?? INITIAL_STATE.annotationColor;
+}
+function annotationColorFromRecord(value) {
+    if (!value || 'object' != typeof value) return null;
+    const record = value;
+    return normalizeAnnotationColor(record.color ?? record.strokeColor);
+}
+function annotationNumberFromRecord(value, attribute, normalize) {
+    if (!annotationRecordSupports(value, attribute)) return null;
+    return normalize(value[attribute]);
+}
+function annotationRecordSupports(value, attribute) {
+    return Boolean(value && 'object' == typeof value && attribute in value);
+}
+function normalizeAnnotationColor(value) {
+    if ('string' != typeof value || !/^#[0-9a-f]{6}$/i.test(value.trim())) return null;
+    return value.trim().toLowerCase();
+}
+function normalizeAnnotationOpacity(value) {
+    return 'number' == typeof value && Number.isFinite(value) && value >= 0 && value <= 1 ? value : null;
+}
+function normalizeAnnotationStrokeWidth(value) {
+    return 'number' == typeof value && Number.isFinite(value) && value > 0 && value <= 24 ? value : null;
+}
+function activeAnnotationScope(capabilities) {
+    const documentId = safely(()=>capabilities?.documentManager?.getActiveDocumentId()) ?? null;
+    if (!documentId) return null;
+    return safely(()=>capabilities?.annotation?.forDocument(documentId)) ?? null;
+}
+function subscribe(unsubscribe, event, listener) {
+    if (!event) return;
+    const stop = safely(()=>event(()=>listener()));
+    if (stop) unsubscribe.push(stop);
+}
+function safely(action) {
+    try {
+        return action();
+    } catch  {
+        return;
+    }
+}
+function createPdfEditorExtensions() {
+    return [
+        createOfficeEditorExtension({
+            name: 'pdfDocument',
+            addCommands: ()=>({
+                    save: {
+                        canExecute: canSave,
+                        execute: ({ save })=>save.execute()
+                    }
+                })
+        }),
+        createOfficeEditorExtension({
+            name: 'pdfHistory',
+            addCommands: ()=>({
+                    redo: {
+                        canExecute: ({ editable, viewer })=>editable && documentReady(viewer) && viewer.state.features.history && viewer.state.canRedo,
+                        execute: ({ viewer })=>viewer.redo()
+                    },
+                    undo: {
+                        canExecute: ({ editable, viewer })=>editable && documentReady(viewer) && viewer.state.features.history && viewer.state.canUndo,
+                        execute: ({ viewer })=>viewer.undo()
+                    }
+                })
+        }),
+        createOfficeEditorExtension({
+            name: 'pdfNavigation',
+            addCommands: ()=>({
+                    goToPage: {
+                        canExecute: ({ viewer }, page)=>canNavigate(viewer) && Number.isInteger(page) && page >= 1 && page <= viewer.state.totalPages,
+                        execute: ({ viewer }, page)=>viewer.goToPage(page)
+                    },
+                    nextPage: {
+                        canExecute: ({ viewer })=>canNavigate(viewer) && viewer.state.currentPage < viewer.state.totalPages,
+                        execute: ({ viewer })=>viewer.nextPage()
+                    },
+                    previousPage: {
+                        canExecute: ({ viewer })=>canNavigate(viewer) && viewer.state.currentPage > 1,
+                        execute: ({ viewer })=>viewer.previousPage()
+                    }
+                })
+        }),
+        createOfficeEditorExtension({
+            name: 'pdfSearch',
+            addCommands: ()=>({
+                    clearSearch: {
+                        canExecute: ({ viewer })=>canSearch(viewer),
+                        execute: ({ viewer })=>viewer.clearSearch()
+                    },
+                    nextSearchResult: {
+                        canExecute: ({ viewer })=>canNavigateSearchResults(viewer),
+                        execute: ({ viewer })=>viewer.nextSearchResult()
+                    },
+                    previousSearchResult: {
+                        canExecute: ({ viewer })=>canNavigateSearchResults(viewer),
+                        execute: ({ viewer })=>viewer.previousSearchResult()
+                    },
+                    search: {
+                        canExecute: ({ viewer })=>canSearch(viewer),
+                        execute: ({ viewer }, query)=>viewer.search(query)
+                    }
+                })
+        }),
+        createOfficeEditorExtension({
+            name: 'pdfZoom',
+            addCommands: ()=>({
+                    fitPage: {
+                        canExecute: ({ viewer })=>canZoom(viewer),
+                        execute: ({ viewer })=>viewer.fitPage()
+                    },
+                    fitWidth: {
+                        canExecute: ({ viewer })=>canZoom(viewer),
+                        execute: ({ viewer })=>viewer.fitWidth()
+                    },
+                    zoomIn: {
+                        canExecute: ({ viewer })=>canZoom(viewer),
+                        execute: ({ viewer })=>viewer.zoomIn()
+                    },
+                    zoomOut: {
+                        canExecute: ({ viewer })=>canZoom(viewer),
+                        execute: ({ viewer })=>viewer.zoomOut()
+                    }
+                })
+        }),
+        createOfficeEditorExtension({
+            name: 'pdfAnnotations',
+            addCommands: ()=>({
+                    deleteAnnotationSelection: {
+                        canExecute: ({ annotation, editable, viewer })=>editable && documentReady(viewer) && annotation.state.available && annotation.state.selectedCount > 0,
+                        execute: ({ annotation })=>annotation.deleteSelection()
+                    },
+                    selectAnnotationTool: {
+                        canExecute: ({ annotation, editable, viewer }, toolId)=>editable && documentReady(viewer) && annotation.state.available && (null === toolId || annotation.state.availableToolIds.includes(toolId)),
+                        execute: ({ annotation }, toolId)=>annotation.selectTool(toolId)
+                    },
+                    setAnnotationColor: {
+                        canExecute: ({ annotation, editable, viewer }, color)=>editable && documentReady(viewer) && annotation.state.available && (annotation.state.selectedCount > 0 || Boolean(annotation.state.activeToolId)) && /^#[0-9a-f]{6}$/i.test(color),
+                        execute: ({ annotation }, color)=>annotation.setAnnotationColor(color)
+                    },
+                    setAnnotationOpacity: {
+                        canExecute: ({ annotation, editable, viewer }, opacity)=>editable && documentReady(viewer) && annotation.state.available && annotation.state.supportsOpacity && Number.isFinite(opacity) && opacity >= 0 && opacity <= 1,
+                        execute: ({ annotation }, opacity)=>annotation.setAnnotationOpacity(opacity)
+                    },
+                    setAnnotationStrokeWidth: {
+                        canExecute: ({ annotation, editable, viewer }, strokeWidth)=>editable && documentReady(viewer) && annotation.state.available && annotation.state.supportsStrokeWidth && Number.isFinite(strokeWidth) && strokeWidth > 0 && strokeWidth <= 24,
+                        execute: ({ annotation }, strokeWidth)=>annotation.setAnnotationStrokeWidth(strokeWidth)
+                    }
+                })
+        }),
+        createOfficeEditorExtension({
+            name: 'pdfKeyboardShortcuts',
+            addKeyboardShortcuts: ()=>({
+                    'Mod-s': ({ can, commands }, event)=>runPdfShortcut(event, can.save, ()=>{
+                            commands.save();
+                        }),
+                    'Mod-z': ({ can, commands }, event)=>runPdfTextAwareShortcut(event, can.undo, commands.undo),
+                    'Mod-Shift-z': ({ can, commands }, event)=>runPdfTextAwareShortcut(event, can.redo, commands.redo),
+                    'Mod-y': ({ can, commands }, event)=>runPdfTextAwareShortcut(event, can.redo, commands.redo),
+                    'Mod-Equal': ({ can, commands }, event)=>runPdfShortcut(event, can.zoomIn, commands.zoomIn),
+                    'Mod-Shift-Plus': ({ can, commands }, event)=>runPdfShortcut(event, can.zoomIn, commands.zoomIn),
+                    'Mod-Minus': ({ can, commands }, event)=>runPdfShortcut(event, can.zoomOut, commands.zoomOut),
+                    'Mod-0': ({ can, commands }, event)=>runPdfShortcut(event, can.fitPage, commands.fitPage),
+                    'Mod-f': ({ can, context }, event)=>{
+                        if (event.repeat || isOfficeShortcutBlocked(event.target) || !can.search('')) return false;
+                        context.focusSearch();
+                        return true;
+                    },
+                    Delete: ({ can, commands }, event)=>runPdfTextAwareShortcut(event, can.deleteAnnotationSelection, commands.deleteAnnotationSelection),
+                    Backspace: ({ can, commands }, event)=>runPdfTextAwareShortcut(event, can.deleteAnnotationSelection, commands.deleteAnnotationSelection),
+                    Escape: ({ can, commands, context }, event)=>{
+                        if (event.repeat || isOfficeShortcutBlocked(event.target) || isPdfTextEditingTarget(event.target) || !context.annotation.state.activeToolId || !can.selectAnnotationTool(null)) return false;
+                        commands.selectAnnotationTool(null);
+                        return true;
+                    }
+                })
+        })
+    ];
+}
+function runPdfShortcut(event, canExecute, execute) {
+    if (event.repeat || isOfficeShortcutBlocked(event.target) || !canExecute()) return false;
+    execute();
+    return true;
+}
+function runPdfTextAwareShortcut(event, canExecute, execute) {
+    if (isPdfTextEditingTarget(event.target)) return false;
+    return runPdfShortcut(event, canExecute, execute);
+}
+function isPdfTextEditingTarget(target) {
+    if (!(target instanceof HTMLElement)) return false;
+    return target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement || target instanceof HTMLSelectElement || target.isContentEditable || Boolean(target.closest('[contenteditable="true"]'));
+}
+function documentReady(viewer) {
+    return viewer.state.ready && viewer.state.documentOpen;
+}
+function canNavigateSearchResults(viewer) {
+    return canSearch(viewer) && !viewer.state.search.loading && !viewer.state.search.error && viewer.state.search.total > 0;
+}
+function canNavigate(viewer) {
+    return documentReady(viewer) && viewer.state.features.navigation;
+}
+function canSearch(viewer) {
+    return documentReady(viewer) && viewer.state.features.search;
+}
+function canZoom(viewer) {
+    return documentReady(viewer) && viewer.state.features.zoom;
+}
+function canSave({ editable, save, viewer }) {
+    return editable && save.enabled && documentReady(viewer) && viewer.state.features.export;
+}
+const PDF_THUMBNAIL_ITEM_HEIGHT = 190;
+const PDF_THUMBNAIL_WINDOW_THRESHOLD = 48;
+const PDF_THUMBNAIL_OVERSCAN = 5;
+const PDF_THUMBNAIL_FALLBACK_VIEWPORT_HEIGHT = 720;
+const PDF_THUMBNAIL_WINDOW_LIMIT = 32;
+function PdfThumbnailRail({ currentPage, mobileCloseButtonRef, mobileNavigationId, mobileNavigationModal = false, registry, totalPages, onCloseMobileNavigation, onSelectPage }) {
+    const viewportRef = useRef(null);
+    const pendingKeyboardFocusPageRef = useRef(null);
+    const [anchorIndex, setAnchorIndex] = useState(()=>pdf_thumbnail_rail_pageIndex(currentPage, totalPages));
+    const [viewportHeight, setViewportHeight] = useState(PDF_THUMBNAIL_FALLBACK_VIEWPORT_HEIGHT);
+    const [itemHeight, setItemHeight] = useState(PDF_THUMBNAIL_ITEM_HEIGHT);
+    useEffect(()=>{
+        setAnchorIndex(pdf_thumbnail_rail_pageIndex(currentPage, totalPages));
+    }, [
+        currentPage,
+        totalPages
+    ]);
+    useLayoutEffect(()=>{
+        const viewport = viewportRef.current;
+        if (!viewport) return;
+        const update = ()=>{
+            if (viewport.clientHeight > 0) setViewportHeight(viewport.clientHeight);
+        };
+        update();
+        if ("u" < typeof ResizeObserver) return;
+        const observer = new ResizeObserver(update);
+        observer.observe(viewport);
+        return ()=>observer.disconnect();
+    }, []);
+    useLayoutEffect(()=>{
+        const viewport = viewportRef.current;
+        if (!viewport || currentPage < 1) return;
+        const index = pdf_thumbnail_rail_pageIndex(currentPage, totalPages);
+        const pageTop = index * itemHeight;
+        const pageBottom = pageTop + itemHeight;
+        const visibleTop = viewport.scrollTop;
+        const visibleBottom = visibleTop + viewportHeight;
+        if (pageTop >= visibleTop && pageBottom <= visibleBottom) return;
+        const top = Math.max(0, pageTop - (viewportHeight - itemHeight) / 2);
+        if ('function' == typeof viewport.scrollTo) viewport.scrollTo({
+            top,
+            behavior: 'smooth'
+        });
+        else viewport.scrollTop = top;
+    }, [
+        currentPage,
+        itemHeight,
+        totalPages,
+        viewportHeight
+    ]);
+    const range = useMemo(()=>calculatePdfThumbnailRange({
+            anchorIndex,
+            itemHeight,
+            totalPages,
+            viewportHeight
+        }), [
+        anchorIndex,
+        itemHeight,
+        totalPages,
+        viewportHeight
+    ]);
+    const pages = useMemo(()=>Array.from({
+            length: Math.max(0, range.end - range.start)
+        }, (_, index)=>range.start + index + 1), [
+        range.end,
+        range.start
+    ]);
+    useLayoutEffect(()=>{
+        const pendingPage = pendingKeyboardFocusPageRef.current;
+        if (null === pendingPage || currentPage !== pendingPage) return;
+        const thumbnail = viewportRef.current?.querySelector(`[data-pdf-page-index="${pendingPage - 1}"]`);
+        if (!thumbnail) return;
+        pendingKeyboardFocusPageRef.current = null;
+        thumbnail.focus({
+            preventScroll: true
+        });
+    }, [
+        currentPage,
+        range.end,
+        range.start
+    ]);
+    useLayoutEffect(()=>{
+        const viewport = viewportRef.current;
+        const thumbnail = viewport?.querySelector('[data-pdf-page-thumbnail]');
+        const list = viewport?.querySelector('.work-pdf-thumbnail-list');
+        if (!(thumbnail && list)) return;
+        const measure = ()=>{
+            const height = thumbnail.getBoundingClientRect().height;
+            const gap = Number.parseFloat(getComputedStyle(list).rowGap) || 0;
+            if (height > 0) setItemHeight(Math.round(height + gap));
+        };
+        measure();
+        if ("u" < typeof ResizeObserver) return;
+        const observer = new ResizeObserver(measure);
+        observer.observe(thumbnail);
+        return ()=>observer.disconnect();
+    }, [
+        range.end,
+        range.start
+    ]);
+    const topSpacerHeight = range.start * itemHeight;
+    const bottomSpacerHeight = Math.max(0, totalPages - range.end) * itemHeight;
+    const modalAttributes = mobileNavigationModal ? {
+        role: 'dialog',
+        'aria-modal': true
+    } : {};
+    return /*#__PURE__*/ jsxs("aside", {
+        ...modalAttributes,
+        id: mobileNavigationId,
+        className: "work-pdf-thumbnail-rail",
+        "aria-label": "PDF 页面",
+        "data-pdf-page-count": totalPages,
+        "data-pdf-thumbnail-window-end": range.end,
+        "data-pdf-thumbnail-window-start": range.start,
+        "data-pdf-thumbnail-windowed": range.windowed ? 'true' : 'false',
+        children: [
+            /*#__PURE__*/ jsxs("header", {
+                className: "work-pdf-thumbnail-header",
+                children: [
+                    /*#__PURE__*/ jsx("strong", {
+                        children: "页面"
+                    }),
+                    /*#__PURE__*/ jsx("button", {
+                        ref: mobileCloseButtonRef,
+                        type: "button",
+                        "aria-label": "关闭 PDF 页面导航",
+                        onClick: onCloseMobileNavigation,
+                        children: /*#__PURE__*/ jsx(X, {
+                            size: 16
+                        })
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsx("nav", {
+                ref: viewportRef,
+                className: "work-pdf-thumbnail-viewport",
+                "aria-label": "PDF 页面缩略图",
+                onScroll: (event)=>{
+                    setAnchorIndex(Math.floor(event.currentTarget.scrollTop / itemHeight));
+                },
+                children: /*#__PURE__*/ jsxs("div", {
+                    className: "work-pdf-thumbnail-list",
+                    children: [
+                        /*#__PURE__*/ jsx(PdfThumbnailSpacer, {
+                            height: topSpacerHeight,
+                            position: "before"
+                        }),
+                        pages.map((page)=>/*#__PURE__*/ jsx(PdfPageThumbnail, {
+                                current: page === currentPage,
+                                page: page,
+                                registry: registry,
+                                totalPages: totalPages,
+                                onSelectPage: onSelectPage,
+                                onSelectPageFromKeyboard: (nextPage)=>{
+                                    if (!mobileNavigationModal) pendingKeyboardFocusPageRef.current = nextPage;
+                                    onSelectPage(nextPage);
+                                }
+                            }, page)),
+                        /*#__PURE__*/ jsx(PdfThumbnailSpacer, {
+                            height: bottomSpacerHeight,
+                            position: "after"
+                        })
+                    ]
+                })
+            })
+        ]
+    });
+}
+function calculatePdfThumbnailRange({ anchorIndex, itemHeight = PDF_THUMBNAIL_ITEM_HEIGHT, totalPages, viewportHeight }) {
+    const pageCount = Math.max(0, Math.floor(totalPages));
+    if (pageCount <= PDF_THUMBNAIL_WINDOW_THRESHOLD) return {
+        end: pageCount,
+        start: 0,
+        windowed: false
+    };
+    const visibleCount = Math.max(1, Math.ceil(Math.max(1, viewportHeight) / Math.max(1, itemHeight)));
+    const windowCount = Math.min(PDF_THUMBNAIL_WINDOW_LIMIT, pageCount, visibleCount + 2 * PDF_THUMBNAIL_OVERSCAN);
+    const boundedAnchor = Math.min(pageCount - 1, Math.max(0, Math.floor(anchorIndex)));
+    const start = Math.min(pageCount - windowCount, Math.max(0, boundedAnchor - PDF_THUMBNAIL_OVERSCAN));
+    return {
+        end: start + windowCount,
+        start,
+        windowed: true
+    };
+}
+function PdfPageThumbnail({ current, page, registry, totalPages, onSelectPage, onSelectPageFromKeyboard }) {
+    const { sourceUrl, state } = usePdfThumbnailSource(registry, page);
+    return /*#__PURE__*/ jsxs("button", {
+        type: "button",
+        className: current ? 'active' : void 0,
+        "aria-current": current ? 'page' : void 0,
+        "aria-label": `第 ${page} 页`,
+        "data-pdf-page-thumbnail": true,
+        "data-pdf-page-index": page - 1,
+        onClick: ()=>onSelectPage(page),
+        onKeyDown: (event)=>{
+            const nextPage = pdfThumbnailKeyboardPage(event.key, page, totalPages);
+            if (null === nextPage) return;
+            event.preventDefault();
+            event.stopPropagation();
+            onSelectPageFromKeyboard(nextPage);
+        },
+        children: [
+            /*#__PURE__*/ jsx("span", {
+                className: "work-pdf-thumbnail-number",
+                "aria-hidden": "true",
+                children: page
+            }),
+            /*#__PURE__*/ jsx("span", {
+                className: "work-pdf-thumbnail-preview",
+                "data-pdf-thumbnail-state": state,
+                children: sourceUrl && /*#__PURE__*/ jsx("img", {
+                    src: sourceUrl,
+                    alt: "",
+                    draggable: false
+                })
+            })
+        ]
+    });
+}
+function usePdfThumbnailSource(registry, page) {
+    const [sourceUrl, setSourceUrl] = useState(null);
+    const [state, setState] = useState('loading');
+    useEffect(()=>{
+        let disposed = false;
+        let objectUrl = null;
+        setSourceUrl(null);
+        setState('loading');
+        renderPdfThumbnail(registry, page).then((blob)=>{
+            objectUrl = URL.createObjectURL(blob);
+            if (disposed) return void URL.revokeObjectURL(objectUrl);
+            setSourceUrl(objectUrl);
+            setState('ready');
+        }).catch(()=>{
+            if (!disposed) setState('error');
+        });
+        return ()=>{
+            disposed = true;
+            if (objectUrl) URL.revokeObjectURL(objectUrl);
+        };
+    }, [
+        page,
+        registry
+    ]);
+    return {
+        sourceUrl,
+        state
+    };
+}
+async function renderPdfThumbnail(registry, page) {
+    await registry.pluginsReady();
+    const documentManager = registry.getPlugin(DocumentManagerPlugin.id)?.provides();
+    const thumbnail = registry.getPlugin(ThumbnailPlugin.id)?.provides();
+    const documentId = documentManager?.getActiveDocumentId();
+    if (!documentId || !thumbnail) throw new Error('PDF thumbnail rendering is unavailable.');
+    const devicePixelRatio = "u" < typeof window ? 1 : Math.min(2, Math.max(1, window.devicePixelRatio || 1));
+    return thumbnail.forDocument(documentId).renderThumb(page - 1, devicePixelRatio).toPromise();
+}
+function PdfThumbnailSpacer({ height, position }) {
+    if (height <= 0) return null;
+    return /*#__PURE__*/ jsx("span", {
+        "aria-hidden": "true",
+        className: "work-pdf-thumbnail-spacer",
+        "data-pdf-thumbnail-spacer": position,
+        style: {
+            height: `${height}px`
+        }
+    });
+}
+function pdf_thumbnail_rail_pageIndex(currentPage, totalPages) {
+    return Math.min(Math.max(0, Math.floor(totalPages) - 1), Math.max(0, Math.floor(currentPage) - 1));
+}
+function pdfThumbnailKeyboardPage(key, page, totalPages) {
+    if ('Home' === key) return 1;
+    if ('End' === key) return totalPages;
+    if ('ArrowUp' === key || 'ArrowLeft' === key) return Math.max(1, page - 1);
+    if ('ArrowDown' === key || 'ArrowRight' === key) return Math.min(totalPages, page + 1);
+    return null;
+}
+function StatusBadge({ tone = 'neutral', children, className = '' }) {
+    return /*#__PURE__*/ jsx("span", {
+        className: `ds-status-badge ${tone}${className ? ` ${className}` : ''}`,
+        children: children
+    });
+}
+const pdfKeyboardShortcuts = {
+    deleteAnnotation: 'Delete Backspace',
+    fitPage: 'Control+0 Meta+0',
+    redo: 'Control+Shift+Z Meta+Shift+Z Control+Y Meta+Y',
+    save: 'Control+S Meta+S',
+    search: 'Control+F Meta+F',
+    undo: 'Control+Z Meta+Z',
+    zoomIn: 'Control+= Meta+= Control+Shift++ Meta+Shift++',
+    zoomOut: 'Control+- Meta+-'
+};
+function PdfToolbar({ annotationState, can, commands, editable, pageNavigation, saveLabel, saveState, searchInputRef, state }) {
+    const [pageValue, setPageValue] = useState('');
+    const [searchValue, setSearchValue] = useState('');
+    const cancelPageBlurCommitRef = useRef(false);
+    useEffect(()=>{
+        setPageValue(state.currentPage > 0 ? String(state.currentPage) : '');
+    }, [
+        state.currentPage
+    ]);
+    useEffect(()=>{
+        setSearchValue(state.search.query);
+    }, [
+        state.search.query
+    ]);
+    const commitPage = ()=>{
+        const page = Number(pageValue);
+        if (can.goToPage(page)) return void commands.goToPage(page);
+        setPageValue(state.currentPage > 0 ? String(state.currentPage) : '');
+    };
+    const submitSearch = (event)=>{
+        event.preventDefault();
+        const query = searchValue.trim();
+        if (query && query === state.search.query) {
+            if (state.search.loading) return;
+            if (state.search.error) return void commands.search(query);
+            if (state.search.total > 0 && can.nextSearchResult()) commands.nextSearchResult();
+            return;
+        }
+        commands.search(query);
+    };
+    return /*#__PURE__*/ jsxs("header", {
+        className: "work-pdf-toolbar",
+        role: "toolbar",
+        "aria-label": "PDF 工具栏",
+        children: [
+            editable && /*#__PURE__*/ jsxs("div", {
+                className: "work-pdf-toolbar-group work-pdf-save",
+                children: [
+                    /*#__PURE__*/ jsxs("output", {
+                        "aria-label": "PDF 保存状态",
+                        "aria-live": "polite",
+                        children: [
+                            'saving' === saveState && /*#__PURE__*/ jsxs(StatusBadge, {
+                                tone: "info",
+                                children: [
+                                    /*#__PURE__*/ jsx(Loader2, {
+                                        className: "spin",
+                                        size: 12
+                                    }),
+                                    " 保存中"
+                                ]
+                            }),
+                            'saved' === saveState && /*#__PURE__*/ jsxs(StatusBadge, {
+                                tone: "success",
+                                children: [
+                                    /*#__PURE__*/ jsx(Check, {
+                                        size: 12
+                                    }),
+                                    " 已保存"
+                                ]
+                            }),
+                            'error' === saveState && /*#__PURE__*/ jsx(StatusBadge, {
+                                tone: "danger",
+                                children: "保存失败"
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ jsxs(button_Button, {
+                        tone: "secondary",
+                        title: `${saveLabel}（Cmd/Ctrl+S）`,
+                        "aria-keyshortcuts": pdfKeyboardShortcuts.save,
+                        disabled: !can.save(),
+                        onClick: ()=>void commands.save(),
+                        children: [
+                            /*#__PURE__*/ jsx(Save, {
+                                size: 14
+                            }),
+                            saveLabel
+                        ]
+                    })
+                ]
+            }),
+            editable && /*#__PURE__*/ jsxs("div", {
+                className: "work-pdf-toolbar-group work-pdf-history",
+                children: [
+                    /*#__PURE__*/ jsx(icon_button_IconButton, {
+                        label: "撤销",
+                        title: "撤销（Cmd/Ctrl+Z）",
+                        "aria-keyshortcuts": pdfKeyboardShortcuts.undo,
+                        disabled: !can.undo(),
+                        onClick: commands.undo,
+                        children: /*#__PURE__*/ jsx(Undo2, {
+                            size: 15
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(icon_button_IconButton, {
+                        label: "重做",
+                        title: "重做（Cmd/Ctrl+Shift+Z 或 Cmd/Ctrl+Y）",
+                        "aria-keyshortcuts": pdfKeyboardShortcuts.redo,
+                        disabled: !can.redo(),
+                        onClick: commands.redo,
+                        children: /*#__PURE__*/ jsx(Redo2, {
+                            size: 15
+                        })
+                    })
+                ]
+            }),
+            editable && /*#__PURE__*/ jsxs("fieldset", {
+                className: "work-pdf-toolbar-group work-pdf-annotation",
+                children: [
+                    /*#__PURE__*/ jsx("legend", {
+                        className: "sr-only",
+                        children: "PDF 批注工具"
+                    }),
+                    /*#__PURE__*/ jsx(icon_button_IconButton, {
+                        className: "work-pdf-annotation-selection",
+                        label: "选择",
+                        selected: null === annotationState.activeToolId,
+                        disabled: !can.selectAnnotationTool(null),
+                        onClick: ()=>commands.selectAnnotationTool(null),
+                        children: /*#__PURE__*/ jsx(MousePointer2, {
+                            size: 14
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(icon_button_IconButton, {
+                        label: "高亮",
+                        selected: 'highlight' === annotationState.activeToolId,
+                        disabled: !can.selectAnnotationTool('highlight'),
+                        onClick: ()=>commands.selectAnnotationTool('highlight'),
+                        children: /*#__PURE__*/ jsx(Highlighter, {
+                            size: 14
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(icon_button_IconButton, {
+                        className: "work-pdf-annotation-optional",
+                        label: "下划线批注",
+                        selected: 'underline' === annotationState.activeToolId,
+                        disabled: !can.selectAnnotationTool('underline'),
+                        onClick: ()=>commands.selectAnnotationTool('underline'),
+                        children: /*#__PURE__*/ jsx(Underline, {
+                            size: 14
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(icon_button_IconButton, {
+                        className: "work-pdf-annotation-optional",
+                        label: "删除线批注",
+                        selected: 'strikeout' === annotationState.activeToolId,
+                        disabled: !can.selectAnnotationTool('strikeout'),
+                        onClick: ()=>commands.selectAnnotationTool('strikeout'),
+                        children: /*#__PURE__*/ jsx(Strikethrough, {
+                            size: 14
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(icon_button_IconButton, {
+                        className: "work-pdf-annotation-ink",
+                        label: "画笔",
+                        selected: 'ink' === annotationState.activeToolId,
+                        disabled: !can.selectAnnotationTool('ink'),
+                        onClick: ()=>commands.selectAnnotationTool('ink'),
+                        children: /*#__PURE__*/ jsx(Pencil, {
+                            size: 14
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(icon_button_IconButton, {
+                        className: "work-pdf-annotation-optional",
+                        label: "文字批注",
+                        selected: 'freeText' === annotationState.activeToolId,
+                        disabled: !can.selectAnnotationTool('freeText'),
+                        onClick: ()=>commands.selectAnnotationTool('freeText'),
+                        children: /*#__PURE__*/ jsx(Type, {
+                            size: 14
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(OfficeColorPicker, {
+                        ariaLabel: "批注颜色",
+                        className: "work-pdf-annotation-color",
+                        compact: true,
+                        value: annotationState.annotationColor,
+                        disabled: !can.setAnnotationColor(annotationState.annotationColor),
+                        onValueChange: commands.setAnnotationColor
+                    }),
+                    /*#__PURE__*/ jsx(PdfAnnotationStyleControl, {
+                        annotationState: annotationState,
+                        can: can,
+                        commands: commands
+                    }),
+                    /*#__PURE__*/ jsx(icon_button_IconButton, {
+                        className: "work-pdf-annotation-delete",
+                        label: "删除所选批注",
+                        title: "删除所选批注（Delete / Backspace）",
+                        "aria-keyshortcuts": pdfKeyboardShortcuts.deleteAnnotation,
+                        disabled: !can.deleteAnnotationSelection(),
+                        onClick: commands.deleteAnnotationSelection,
+                        children: /*#__PURE__*/ jsx(Trash2, {
+                            size: 14
+                        })
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsx(PdfToolbarOverflow, {
+                annotationState: annotationState,
+                can: can,
+                commands: commands,
+                editable: editable,
+                state: state
+            }),
+            /*#__PURE__*/ jsx("search", {
+                className: "work-pdf-search",
+                children: /*#__PURE__*/ jsxs("form", {
+                    onSubmit: submitSearch,
+                    children: [
+                        /*#__PURE__*/ jsx(Search, {
+                            size: 14,
+                            "aria-hidden": "true"
+                        }),
+                        /*#__PURE__*/ jsx(office_text_field_OfficeTextField, {
+                            ref: searchInputRef,
+                            type: "search",
+                            "aria-label": "在 PDF 中搜索",
+                            "aria-keyshortcuts": pdfKeyboardShortcuts.search,
+                            placeholder: "搜索",
+                            value: searchValue,
+                            disabled: !can.search(searchValue),
+                            onChange: (event)=>setSearchValue(event.target.value),
+                            onKeyDown: (event)=>{
+                                if ('Escape' === event.key) {
+                                    event.preventDefault();
+                                    event.stopPropagation();
+                                    setSearchValue('');
+                                    commands.clearSearch();
+                                } else if ('Enter' === event.key && event.shiftKey && searchValue.trim() === state.search.query) {
+                                    event.preventDefault();
+                                    event.stopPropagation();
+                                    if (!state.search.loading && !state.search.error && state.search.total > 0 && can.previousSearchResult()) commands.previousSearchResult();
+                                }
+                            }
+                        }),
+                        (searchValue || state.search.active) && /*#__PURE__*/ jsx(icon_button_IconButton, {
+                            className: "work-pdf-search-clear",
+                            label: "清除搜索",
+                            onClick: ()=>{
+                                setSearchValue('');
+                                commands.clearSearch();
+                                searchInputRef.current?.focus();
+                            },
+                            children: /*#__PURE__*/ jsx(X, {
+                                size: 13
+                            })
+                        }),
+                        /*#__PURE__*/ jsx("output", {
+                            className: "work-pdf-search-state",
+                            "aria-live": "polite",
+                            children: searchStatus(state)
+                        }),
+                        /*#__PURE__*/ jsx(icon_button_IconButton, {
+                            label: "上一个搜索结果",
+                            disabled: !can.previousSearchResult(),
+                            onClick: commands.previousSearchResult,
+                            children: /*#__PURE__*/ jsx(ChevronUp, {
+                                size: 14
+                            })
+                        }),
+                        /*#__PURE__*/ jsx(icon_button_IconButton, {
+                            label: "下一个搜索结果",
+                            disabled: !can.nextSearchResult(),
+                            onClick: commands.nextSearchResult,
+                            children: /*#__PURE__*/ jsx(ChevronDown, {
+                                size: 14
+                            })
+                        })
+                    ]
+                })
+            }),
+            /*#__PURE__*/ jsxs("div", {
+                className: "work-pdf-toolbar-group work-pdf-page-controls",
+                children: [
+                    pageNavigation && /*#__PURE__*/ jsxs(icon_button_IconButton, {
+                        ref: pageNavigation.toggleRef,
+                        className: "work-pdf-page-navigation-toggle",
+                        label: "打开 PDF 页面导航",
+                        tooltip: "页面缩略图",
+                        "aria-controls": pageNavigation.controlsId,
+                        "aria-expanded": pageNavigation.expanded,
+                        onClick: pageNavigation.onOpen,
+                        children: [
+                            /*#__PURE__*/ jsx(GalleryVerticalEnd, {
+                                size: 15
+                            }),
+                            /*#__PURE__*/ jsxs("span", {
+                                className: "sr-only",
+                                children: [
+                                    "第 ",
+                                    Math.max(1, state.currentPage),
+                                    " 页"
+                                ]
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ jsx(icon_button_IconButton, {
+                        className: "work-pdf-page-step",
+                        label: "上一页",
+                        disabled: !can.previousPage(),
+                        onClick: commands.previousPage,
+                        children: /*#__PURE__*/ jsx(ChevronLeft, {
+                            size: 15
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(office_text_field_OfficeTextField, {
+                        className: "work-pdf-page-field",
+                        "aria-label": "页码",
+                        inputMode: "numeric",
+                        value: pageValue,
+                        disabled: !can.goToPage(state.currentPage || 1),
+                        onBlur: ()=>{
+                            if (cancelPageBlurCommitRef.current) {
+                                cancelPageBlurCommitRef.current = false;
+                                return;
+                            }
+                            commitPage();
+                        },
+                        onFocus: ()=>{
+                            cancelPageBlurCommitRef.current = false;
+                        },
+                        onChange: (event)=>setPageValue(event.target.value.replace(/\D/g, '')),
+                        onKeyDown: (event)=>{
+                            if ('Enter' === event.key) {
+                                event.preventDefault();
+                                commitPage();
+                                event.currentTarget.select();
+                            } else if ('Escape' === event.key) {
+                                event.preventDefault();
+                                event.stopPropagation();
+                                cancelPageBlurCommitRef.current = true;
+                                setPageValue(String(state.currentPage));
+                                event.currentTarget.blur();
+                            }
+                        }
+                    }),
+                    /*#__PURE__*/ jsxs("span", {
+                        className: "work-pdf-page-total",
+                        children: [
+                            "/ ",
+                            state.totalPages || '—'
+                        ]
+                    }),
+                    /*#__PURE__*/ jsx(icon_button_IconButton, {
+                        className: "work-pdf-page-step",
+                        label: "下一页",
+                        disabled: !can.nextPage(),
+                        onClick: commands.nextPage,
+                        children: /*#__PURE__*/ jsx(ChevronRight, {
+                            size: 15
+                        })
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsxs("div", {
+                className: "work-pdf-toolbar-group work-pdf-zoom-controls",
+                children: [
+                    /*#__PURE__*/ jsx(icon_button_IconButton, {
+                        label: "缩小",
+                        title: "缩小（Cmd/Ctrl+-）",
+                        "aria-keyshortcuts": pdfKeyboardShortcuts.zoomOut,
+                        disabled: !can.zoomOut(),
+                        onClick: commands.zoomOut,
+                        children: /*#__PURE__*/ jsx(Minus, {
+                            size: 14
+                        })
+                    }),
+                    /*#__PURE__*/ jsxs("output", {
+                        "aria-label": "PDF 缩放比例",
+                        children: [
+                            state.zoomPercent,
+                            "%"
+                        ]
+                    }),
+                    /*#__PURE__*/ jsx(icon_button_IconButton, {
+                        label: "放大",
+                        title: "放大（Cmd/Ctrl++）",
+                        "aria-keyshortcuts": pdfKeyboardShortcuts.zoomIn,
+                        disabled: !can.zoomIn(),
+                        onClick: commands.zoomIn,
+                        children: /*#__PURE__*/ jsx(Plus, {
+                            size: 14
+                        })
+                    }),
+                    /*#__PURE__*/ jsx("button", {
+                        type: "button",
+                        className: "work-pdf-fit-button",
+                        title: "整页（Cmd/Ctrl+0）",
+                        "aria-keyshortcuts": pdfKeyboardShortcuts.fitPage,
+                        "aria-pressed": 'fit-page' === state.zoomMode,
+                        disabled: !can.fitPage(),
+                        onClick: commands.fitPage,
+                        children: "整页"
+                    }),
+                    /*#__PURE__*/ jsx("button", {
+                        type: "button",
+                        className: "work-pdf-fit-button",
+                        "aria-pressed": 'fit-width' === state.zoomMode,
+                        disabled: !can.fitWidth(),
+                        onClick: commands.fitWidth,
+                        children: "页宽"
+                    })
+                ]
+            })
+        ]
+    });
+}
+const PDF_ANNOTATION_OPACITY_OPTIONS = [
+    0.25,
+    0.5,
+    0.75,
+    1
+];
+const PDF_ANNOTATION_STROKE_WIDTH_OPTIONS = [
+    1,
+    2,
+    4,
+    6,
+    10
+];
+function PdfAnnotationStyleControl({ annotationState, can, commands }) {
+    const [open, setOpen] = useState(false);
+    const panelRef = useRef(null);
+    const opacityGroupName = useId();
+    const strokeWidthGroupName = useId();
+    const opacityPercent = Math.round(100 * annotationState.annotationOpacity);
+    const disabled = !can.setAnnotationOpacity(annotationState.annotationOpacity) && !can.setAnnotationStrokeWidth(annotationState.annotationStrokeWidth);
+    const title = annotationState.supportsStrokeWidth ? `批注样式（${opacityPercent}%，线宽 ${annotationState.annotationStrokeWidth}）` : `批注样式（${opacityPercent}%）`;
+    return /*#__PURE__*/ jsx(Popover, {
+        label: "批注样式",
+        panelLabel: "批注样式",
+        panelRole: "dialog",
+        placement: "bottom-end",
+        portal: true,
+        open: open,
+        panelRef: panelRef,
+        onOpenChange: (nextOpen)=>{
+            setOpen(nextOpen);
+            if (!nextOpen) return;
+            requestAnimationFrame(()=>{
+                const panel = panelRef.current;
+                const target = panel?.querySelector('input[type="radio"]:checked:not(:disabled)') ?? panel?.querySelector('input[type="radio"]:not(:disabled)');
+                target?.focus({
+                    preventScroll: true
+                });
+            });
+        },
+        disabled: disabled,
+        className: "work-pdf-annotation-style",
+        panelClassName: "work-pdf-annotation-style-panel",
+        trigger: (triggerProps)=>/*#__PURE__*/ jsx("button", {
+                ...triggerProps,
+                className: "ds-icon-button",
+                title: title,
+                children: /*#__PURE__*/ jsx(SlidersHorizontal, {
+                    size: 14
+                })
+            }),
+        children: /*#__PURE__*/ jsxs("div", {
+            className: "work-pdf-annotation-style-content",
+            children: [
+                annotationState.supportsOpacity && /*#__PURE__*/ jsxs("fieldset", {
+                    className: "work-pdf-annotation-style-row",
+                    children: [
+                        /*#__PURE__*/ jsx("legend", {
+                            children: "透明度"
+                        }),
+                        /*#__PURE__*/ jsx("div", {
+                            className: "work-pdf-annotation-style-options",
+                            children: PDF_ANNOTATION_OPACITY_OPTIONS.map((opacity)=>{
+                                const label = `${Math.round(100 * opacity)}%`;
+                                return /*#__PURE__*/ jsxs("label", {
+                                    children: [
+                                        /*#__PURE__*/ jsx("input", {
+                                            type: "radio",
+                                            name: opacityGroupName,
+                                            "aria-label": `透明度 ${label}`,
+                                            checked: annotationState.annotationOpacity === opacity,
+                                            disabled: !can.setAnnotationOpacity(opacity),
+                                            onChange: ()=>commands.setAnnotationOpacity(opacity),
+                                            onKeyDown: movePdfAnnotationStyleOption
+                                        }),
+                                        /*#__PURE__*/ jsx("span", {
+                                            children: label
+                                        })
+                                    ]
+                                }, opacity);
+                            })
+                        })
+                    ]
+                }),
+                annotationState.supportsStrokeWidth && /*#__PURE__*/ jsxs("fieldset", {
+                    className: "work-pdf-annotation-style-row",
+                    children: [
+                        /*#__PURE__*/ jsx("legend", {
+                            children: "线宽"
+                        }),
+                        /*#__PURE__*/ jsx("div", {
+                            className: "work-pdf-annotation-style-options",
+                            children: PDF_ANNOTATION_STROKE_WIDTH_OPTIONS.map((strokeWidth)=>/*#__PURE__*/ jsxs("label", {
+                                    children: [
+                                        /*#__PURE__*/ jsx("input", {
+                                            type: "radio",
+                                            name: strokeWidthGroupName,
+                                            "aria-label": `线宽 ${strokeWidth}`,
+                                            checked: annotationState.annotationStrokeWidth === strokeWidth,
+                                            disabled: !can.setAnnotationStrokeWidth(strokeWidth),
+                                            onChange: ()=>commands.setAnnotationStrokeWidth(strokeWidth),
+                                            onKeyDown: movePdfAnnotationStyleOption
+                                        }),
+                                        /*#__PURE__*/ jsx("span", {
+                                            children: strokeWidth
+                                        })
+                                    ]
+                                }, strokeWidth))
+                        })
+                    ]
+                })
+            ]
+        })
+    });
+}
+function movePdfAnnotationStyleOption(event) {
+    if (![
+        'ArrowDown',
+        'ArrowLeft',
+        'ArrowRight',
+        'ArrowUp',
+        'Home',
+        'End'
+    ].includes(event.key)) return;
+    const options = [
+        ...event.currentTarget.closest('fieldset')?.querySelectorAll('input[type="radio"]:not(:disabled)') ?? []
+    ];
+    if (!options.length) return;
+    event.preventDefault();
+    const current = options.indexOf(event.currentTarget);
+    const nextIndex = 'Home' === event.key ? 0 : 'End' === event.key ? options.length - 1 : 'ArrowDown' === event.key || 'ArrowRight' === event.key ? (current + 1 + options.length) % options.length : (current - 1 + options.length) % options.length;
+    const next = options[nextIndex];
+    next?.focus({
+        preventScroll: true
+    });
+    next?.click();
+}
+function PdfToolbarOverflow({ annotationState, can, commands, editable, state }) {
+    const hasOverflowTools = editable && annotationState.available || editable && state.features.history || state.features.navigation || state.features.search || state.features.zoom;
+    return /*#__PURE__*/ jsx(Popover, {
+        label: "更多 PDF 工具",
+        panelLabel: "更多 PDF 工具",
+        panelRole: "menu",
+        placement: "bottom-end",
+        portal: true,
+        focusFirstOnOpen: true,
+        onPanelKeyDown: moveOfficeMenuFocus,
+        disabled: !hasOverflowTools,
+        className: "work-pdf-overflow",
+        panelClassName: "work-pdf-overflow-panel",
+        trigger: (triggerProps)=>/*#__PURE__*/ jsx("button", {
+                ...triggerProps,
+                className: "ds-icon-button work-pdf-overflow-trigger",
+                title: "更多 PDF 工具",
+                children: /*#__PURE__*/ jsx(Ellipsis, {
+                    size: 16
+                })
+            }),
+        children: (close)=>{
+            const select = (command)=>{
+                close();
+                command();
+            };
+            return /*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    editable && annotationState.available && /*#__PURE__*/ jsxs("fieldset", {
+                        className: "work-pdf-overflow-group",
+                        "aria-label": "批注工具",
+                        children: [
+                            /*#__PURE__*/ jsx(PdfOverflowAction, {
+                                label: "选择",
+                                active: null === annotationState.activeToolId,
+                                disabled: !can.selectAnnotationTool(null),
+                                onSelect: ()=>select(()=>commands.selectAnnotationTool(null)),
+                                children: /*#__PURE__*/ jsx(MousePointer2, {
+                                    size: 15
+                                })
+                            }),
+                            /*#__PURE__*/ jsx(PdfOverflowAction, {
+                                label: "高亮",
+                                active: 'highlight' === annotationState.activeToolId,
+                                disabled: !can.selectAnnotationTool('highlight'),
+                                onSelect: ()=>select(()=>commands.selectAnnotationTool('highlight')),
+                                children: /*#__PURE__*/ jsx(Highlighter, {
+                                    size: 15
+                                })
+                            }),
+                            /*#__PURE__*/ jsx(PdfOverflowAction, {
+                                label: "画笔",
+                                active: 'ink' === annotationState.activeToolId,
+                                disabled: !can.selectAnnotationTool('ink'),
+                                onSelect: ()=>select(()=>commands.selectAnnotationTool('ink')),
+                                children: /*#__PURE__*/ jsx(Pencil, {
+                                    size: 15
+                                })
+                            }),
+                            /*#__PURE__*/ jsx(PdfOverflowAction, {
+                                label: "下划线批注",
+                                active: 'underline' === annotationState.activeToolId,
+                                disabled: !can.selectAnnotationTool('underline'),
+                                onSelect: ()=>select(()=>commands.selectAnnotationTool('underline')),
+                                children: /*#__PURE__*/ jsx(Underline, {
+                                    size: 15
+                                })
+                            }),
+                            /*#__PURE__*/ jsx(PdfOverflowAction, {
+                                label: "删除线批注",
+                                active: 'strikeout' === annotationState.activeToolId,
+                                disabled: !can.selectAnnotationTool('strikeout'),
+                                onSelect: ()=>select(()=>commands.selectAnnotationTool('strikeout')),
+                                children: /*#__PURE__*/ jsx(Strikethrough, {
+                                    size: 15
+                                })
+                            }),
+                            /*#__PURE__*/ jsx(PdfOverflowAction, {
+                                label: "文字批注",
+                                active: 'freeText' === annotationState.activeToolId,
+                                disabled: !can.selectAnnotationTool('freeText'),
+                                onSelect: ()=>select(()=>commands.selectAnnotationTool('freeText')),
+                                children: /*#__PURE__*/ jsx(Type, {
+                                    size: 15
+                                })
+                            }),
+                            /*#__PURE__*/ jsx(PdfOverflowAction, {
+                                label: "删除所选批注",
+                                ariaKeyShortcuts: pdfKeyboardShortcuts.deleteAnnotation,
+                                disabled: !can.deleteAnnotationSelection(),
+                                onSelect: ()=>select(commands.deleteAnnotationSelection),
+                                children: /*#__PURE__*/ jsx(Trash2, {
+                                    size: 15
+                                })
+                            })
+                        ]
+                    }),
+                    editable && annotationState.available && annotationState.supportsOpacity && /*#__PURE__*/ jsx("fieldset", {
+                        className: "work-pdf-overflow-group",
+                        "aria-label": "透明度",
+                        children: PDF_ANNOTATION_OPACITY_OPTIONS.map((opacity)=>{
+                            const label = `透明度 ${Math.round(100 * opacity)}%`;
+                            return /*#__PURE__*/ jsx(PdfOverflowAction, {
+                                label: label,
+                                active: annotationState.annotationOpacity === opacity,
+                                disabled: !can.setAnnotationOpacity(opacity),
+                                onSelect: ()=>select(()=>commands.setAnnotationOpacity(opacity)),
+                                children: /*#__PURE__*/ jsx(SlidersHorizontal, {
+                                    size: 15
+                                })
+                            }, opacity);
+                        })
+                    }),
+                    editable && annotationState.available && annotationState.supportsStrokeWidth && /*#__PURE__*/ jsx("fieldset", {
+                        className: "work-pdf-overflow-group",
+                        "aria-label": "线宽",
+                        children: PDF_ANNOTATION_STROKE_WIDTH_OPTIONS.map((strokeWidth)=>/*#__PURE__*/ jsx(PdfOverflowAction, {
+                                label: `线宽 ${strokeWidth}`,
+                                active: annotationState.annotationStrokeWidth === strokeWidth,
+                                disabled: !can.setAnnotationStrokeWidth(strokeWidth),
+                                onSelect: ()=>select(()=>commands.setAnnotationStrokeWidth(strokeWidth)),
+                                children: /*#__PURE__*/ jsx(Pencil, {
+                                    size: 15
+                                })
+                            }, strokeWidth))
+                    }),
+                    editable && state.features.history && /*#__PURE__*/ jsxs("fieldset", {
+                        className: "work-pdf-overflow-group",
+                        "aria-label": "历史记录",
+                        children: [
+                            /*#__PURE__*/ jsx(PdfOverflowAction, {
+                                label: "撤销",
+                                ariaKeyShortcuts: pdfKeyboardShortcuts.undo,
+                                disabled: !can.undo(),
+                                onSelect: ()=>select(commands.undo),
+                                children: /*#__PURE__*/ jsx(Undo2, {
+                                    size: 15
+                                })
+                            }),
+                            /*#__PURE__*/ jsx(PdfOverflowAction, {
+                                label: "重做",
+                                ariaKeyShortcuts: pdfKeyboardShortcuts.redo,
+                                disabled: !can.redo(),
+                                onSelect: ()=>select(commands.redo),
+                                children: /*#__PURE__*/ jsx(Redo2, {
+                                    size: 15
+                                })
+                            })
+                        ]
+                    }),
+                    state.features.navigation && /*#__PURE__*/ jsxs("fieldset", {
+                        className: "work-pdf-overflow-group",
+                        "aria-label": "翻页",
+                        children: [
+                            /*#__PURE__*/ jsx(PdfOverflowAction, {
+                                label: "上一页",
+                                disabled: !can.previousPage(),
+                                onSelect: ()=>select(commands.previousPage),
+                                children: /*#__PURE__*/ jsx(ChevronLeft, {
+                                    size: 15
+                                })
+                            }),
+                            /*#__PURE__*/ jsx(PdfOverflowAction, {
+                                label: "下一页",
+                                disabled: !can.nextPage(),
+                                onSelect: ()=>select(commands.nextPage),
+                                children: /*#__PURE__*/ jsx(ChevronRight, {
+                                    size: 15
+                                })
+                            })
+                        ]
+                    }),
+                    state.features.zoom && /*#__PURE__*/ jsxs("fieldset", {
+                        className: "work-pdf-overflow-group",
+                        "aria-label": "缩放",
+                        children: [
+                            /*#__PURE__*/ jsx(PdfOverflowAction, {
+                                label: "缩小",
+                                ariaKeyShortcuts: pdfKeyboardShortcuts.zoomOut,
+                                disabled: !can.zoomOut(),
+                                onSelect: ()=>select(commands.zoomOut),
+                                children: /*#__PURE__*/ jsx(Minus, {
+                                    size: 15
+                                })
+                            }),
+                            /*#__PURE__*/ jsx(PdfOverflowAction, {
+                                label: "放大",
+                                ariaKeyShortcuts: pdfKeyboardShortcuts.zoomIn,
+                                disabled: !can.zoomIn(),
+                                onSelect: ()=>select(commands.zoomIn),
+                                children: /*#__PURE__*/ jsx(Plus, {
+                                    size: 15
+                                })
+                            }),
+                            /*#__PURE__*/ jsx(PdfOverflowAction, {
+                                label: "整页",
+                                active: 'fit-page' === state.zoomMode,
+                                ariaKeyShortcuts: pdfKeyboardShortcuts.fitPage,
+                                disabled: !can.fitPage(),
+                                onSelect: ()=>select(commands.fitPage),
+                                children: /*#__PURE__*/ jsx(Scan, {
+                                    size: 15
+                                })
+                            }),
+                            /*#__PURE__*/ jsx(PdfOverflowAction, {
+                                label: "页宽",
+                                active: 'fit-width' === state.zoomMode,
+                                disabled: !can.fitWidth(),
+                                onSelect: ()=>select(commands.fitWidth),
+                                children: /*#__PURE__*/ jsx(MoveHorizontal, {
+                                    size: 15
+                                })
+                            })
+                        ]
+                    }),
+                    state.features.search && /*#__PURE__*/ jsxs("fieldset", {
+                        className: "work-pdf-overflow-group work-pdf-overflow-narrow",
+                        "aria-label": "搜索结果",
+                        children: [
+                            /*#__PURE__*/ jsx(PdfOverflowAction, {
+                                label: "上一个搜索结果",
+                                disabled: !can.previousSearchResult(),
+                                onSelect: ()=>select(commands.previousSearchResult),
+                                children: /*#__PURE__*/ jsx(ChevronUp, {
+                                    size: 15
+                                })
+                            }),
+                            /*#__PURE__*/ jsx(PdfOverflowAction, {
+                                label: "下一个搜索结果",
+                                disabled: !can.nextSearchResult(),
+                                onSelect: ()=>select(commands.nextSearchResult),
+                                children: /*#__PURE__*/ jsx(ChevronDown, {
+                                    size: 15
+                                })
+                            })
+                        ]
+                    })
+                ]
+            });
+        }
+    });
+}
+function PdfOverflowAction({ active, ariaKeyShortcuts, children, disabled, label, onSelect }) {
+    const content = /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            /*#__PURE__*/ jsx("span", {
+                "aria-hidden": "true",
+                children: children
+            }),
+            /*#__PURE__*/ jsx("span", {
+                children: label
+            }),
+            active && /*#__PURE__*/ jsx(Check, {
+                size: 14,
+                "aria-hidden": "true"
+            })
+        ]
+    });
+    if (void 0 !== active) return /*#__PURE__*/ jsx("button", {
+        type: "button",
+        role: "menuitemradio",
+        "aria-checked": active,
+        "aria-keyshortcuts": ariaKeyShortcuts,
+        tabIndex: -1,
+        "data-active": active ? 'true' : void 0,
+        disabled: disabled,
+        onClick: onSelect,
+        children: content
+    });
+    return /*#__PURE__*/ jsx("button", {
+        type: "button",
+        role: "menuitem",
+        "aria-keyshortcuts": ariaKeyShortcuts,
+        tabIndex: -1,
+        disabled: disabled,
+        onClick: onSelect,
+        children: content
+    });
+}
+function searchStatus(state) {
+    const { search } = state;
+    if (search.loading) return '搜索中';
+    if (search.error) return '失败';
+    if (!search.query && !search.active) return '';
+    if (0 === search.total) return '0 / 0';
+    return `${search.activeResultIndex + 1} / ${search.total}`;
+}
+const EMPTY_FEATURES = {
+    export: false,
+    history: false,
+    navigation: false,
+    search: false,
+    zoom: false
+};
+const EMPTY_SEARCH = {
+    active: false,
+    activeResultIndex: -1,
+    error: false,
+    loading: false,
+    query: '',
+    total: 0
+};
+const initialPdfViewerControllerState = {
+    canRedo: false,
+    canUndo: false,
+    currentPage: 0,
+    documentOpen: false,
+    error: null,
+    features: EMPTY_FEATURES,
+    ready: false,
+    search: EMPTY_SEARCH,
+    totalPages: 0,
+    zoomMode: null,
+    zoomPercent: 100
+};
+function usePdfViewerController(registry) {
+    const capabilitiesRef = useRef(null);
+    const pendingPageRef = useRef(null);
+    const [state, setState] = useState(initialPdfViewerControllerState);
+    useEffect(()=>{
+        let disposed = false;
+        const unsubscribe = [];
+        capabilitiesRef.current = null;
+        pendingPageRef.current = null;
+        setState(initialPdfViewerControllerState);
+        if (!registry) return;
+        registry.pluginsReady().then(()=>{
+            if (disposed) return;
+            const capabilities = readCapabilities(registry);
+            capabilitiesRef.current = capabilities;
+            const sync = ()=>{
+                if (!disposed) setState(readControllerState(capabilities));
+            };
+            const syncDocument = ()=>{
+                pendingPageRef.current = null;
+                sync();
+            };
+            pdf_viewer_controller_subscribe(unsubscribe, capabilities.documentManager?.onActiveDocumentChanged, syncDocument);
+            pdf_viewer_controller_subscribe(unsubscribe, capabilities.documentManager?.onDocumentOpened, syncDocument);
+            pdf_viewer_controller_subscribe(unsubscribe, capabilities.documentManager?.onDocumentClosed, syncDocument);
+            pdf_viewer_controller_subscribe(unsubscribe, capabilities.scroll?.onPageChange, sync);
+            pdf_viewer_controller_subscribe(unsubscribe, capabilities.scroll?.onLayoutReady, sync);
+            const stopPageChangeState = pdf_viewer_controller_safely(()=>capabilities.scroll?.onPageChangeState((event)=>{
+                    if (disposed || event.state.isChanging) return;
+                    const pendingPage = pendingPageRef.current;
+                    if (null === pendingPage) return;
+                    withActiveDocument(capabilities, ({ scroll }, documentId)=>{
+                        if (event.documentId !== documentId) return;
+                        const scope = scroll?.forDocument(documentId);
+                        if (scope) requestPdfPageNavigation(scope, pendingPage, pendingPageRef);
+                    });
+                }));
+            if (stopPageChangeState) unsubscribe.push(stopPageChangeState);
+            pdf_viewer_controller_subscribe(unsubscribe, capabilities.zoom?.onStateChange, sync);
+            pdf_viewer_controller_subscribe(unsubscribe, capabilities.search?.onStateChange, sync);
+            pdf_viewer_controller_subscribe(unsubscribe, capabilities.history?.onHistoryChange, sync);
+            sync();
+        }).catch((error)=>{
+            if (disposed) return;
+            setState({
+                ...initialPdfViewerControllerState,
+                error: errorMessage(error)
+            });
+        });
+        return ()=>{
+            disposed = true;
+            capabilitiesRef.current = null;
+            pendingPageRef.current = null;
+            for (const stop of unsubscribe)stop();
+        };
+    }, [
+        registry
+    ]);
+    const previousPage = useCallback(()=>{
+        withActiveDocument(capabilitiesRef.current, ({ scroll }, documentId)=>{
+            scroll?.forDocument(documentId).scrollToPreviousPage('smooth');
+        });
+    }, []);
+    const nextPage = useCallback(()=>{
+        withActiveDocument(capabilitiesRef.current, ({ scroll }, documentId)=>{
+            scroll?.forDocument(documentId).scrollToNextPage('smooth');
+        });
+    }, []);
+    const goToPage = useCallback((page)=>{
+        withActiveDocument(capabilitiesRef.current, ({ scroll }, documentId)=>{
+            const scope = scroll?.forDocument(documentId);
+            if (!scope) return;
+            requestPdfPageNavigation(scope, page, pendingPageRef);
+        });
+    }, []);
+    const zoomOut = useCallback(()=>{
+        withActiveDocument(capabilitiesRef.current, ({ zoom }, documentId)=>{
+            zoom?.forDocument(documentId).zoomOut();
+        });
+    }, []);
+    const zoomIn = useCallback(()=>{
+        withActiveDocument(capabilitiesRef.current, ({ zoom }, documentId)=>{
+            zoom?.forDocument(documentId).zoomIn();
+        });
+    }, []);
+    const fitPage = useCallback(()=>{
+        withActiveDocument(capabilitiesRef.current, ({ zoom }, documentId)=>{
+            zoom?.forDocument(documentId).requestZoom(ZoomMode.FitPage);
+        });
+    }, []);
+    const fitWidth = useCallback(()=>{
+        withActiveDocument(capabilitiesRef.current, ({ zoom }, documentId)=>{
+            zoom?.forDocument(documentId).requestZoom(ZoomMode.FitWidth);
+        });
+    }, []);
+    const search = useCallback((query)=>{
+        const trimmedQuery = query.trim();
+        withActiveDocument(capabilitiesRef.current, ({ search: searchCapability }, documentId)=>{
+            const scope = searchCapability?.forDocument(documentId);
+            if (!scope) return;
+            if (!trimmedQuery) {
+                scope.searchAllPages('');
+                scope.stopSearch();
+                setState((previous)=>({
+                        ...previous,
+                        search: EMPTY_SEARCH
+                    }));
+                return;
+            }
+            setState((previous)=>({
+                    ...previous,
+                    search: {
+                        ...previous.search,
+                        error: false,
+                        loading: true,
+                        query: trimmedQuery
+                    }
+                }));
+            scope.searchAllPages(trimmedQuery).toPromise().catch(()=>{
+                setState((previous)=>previous.search.query !== trimmedQuery ? previous : {
+                        ...previous,
+                        search: {
+                            ...previous.search,
+                            error: true,
+                            loading: false
+                        }
+                    });
+            });
+        });
+    }, []);
+    const clearSearch = useCallback(()=>{
+        search('');
+    }, [
+        search
+    ]);
+    const previousSearchResult = useCallback(()=>{
+        withActiveDocument(capabilitiesRef.current, ({ search: searchCapability }, documentId)=>{
+            searchCapability?.forDocument(documentId).previousResult();
+        });
+    }, []);
+    const nextSearchResult = useCallback(()=>{
+        withActiveDocument(capabilitiesRef.current, ({ search: searchCapability }, documentId)=>{
+            searchCapability?.forDocument(documentId).nextResult();
+        });
+    }, []);
+    const undo = useCallback(()=>{
+        withActiveDocument(capabilitiesRef.current, ({ history }, documentId)=>{
+            history?.forDocument(documentId).undo();
+        });
+    }, []);
+    const redo = useCallback(()=>{
+        withActiveDocument(capabilitiesRef.current, ({ history }, documentId)=>{
+            history?.forDocument(documentId).redo();
+        });
+    }, []);
+    const saveAsCopy = useCallback(async ()=>{
+        const capabilities = capabilitiesRef.current;
+        const documentId = activeDocumentId(capabilities);
+        if (!capabilities?.export || !documentId) throw new Error('PDF export is unavailable.');
+        const buffer = await capabilities.export.forDocument(documentId).saveAsCopy().toPromise();
+        return new Blob([
+            buffer
+        ], {
+            type: 'application/pdf'
+        });
+    }, []);
+    return useMemo(()=>({
+            state,
+            clearSearch,
+            fitPage,
+            fitWidth,
+            goToPage,
+            nextPage,
+            nextSearchResult,
+            previousPage,
+            previousSearchResult,
+            redo,
+            saveAsCopy,
+            search,
+            undo,
+            zoomIn,
+            zoomOut
+        }), [
+        state,
+        clearSearch,
+        fitPage,
+        fitWidth,
+        goToPage,
+        nextPage,
+        nextSearchResult,
+        previousPage,
+        previousSearchResult,
+        redo,
+        saveAsCopy,
+        search,
+        undo,
+        zoomIn,
+        zoomOut
+    ]);
+}
+function readCapabilities(registry) {
+    return {
+        documentManager: registry.getPlugin(DocumentManagerPlugin.id)?.provides() ?? null,
+        export: registry.getPlugin(ExportPlugin.id)?.provides() ?? null,
+        history: registry.getPlugin(HistoryPlugin.id)?.provides() ?? null,
+        search: registry.getPlugin(SearchPlugin.id)?.provides() ?? null,
+        scroll: registry.getPlugin(ScrollPlugin.id)?.provides() ?? null,
+        zoom: registry.getPlugin(ZoomPlugin.id)?.provides() ?? null
+    };
+}
+function readControllerState(capabilities) {
+    const documentId = activeDocumentId(capabilities);
+    const features = {
+        export: Boolean(capabilities.export),
+        history: Boolean(capabilities.history),
+        navigation: Boolean(capabilities.scroll),
+        search: Boolean(capabilities.search),
+        zoom: Boolean(capabilities.zoom)
+    };
+    if (!documentId) return {
+        ...initialPdfViewerControllerState,
+        features,
+        ready: true
+    };
+    const scroll = pdf_viewer_controller_safely(()=>capabilities.scroll?.forDocument(documentId));
+    const zoom = pdf_viewer_controller_safely(()=>capabilities.zoom?.forDocument(documentId));
+    const search = pdf_viewer_controller_safely(()=>capabilities.search?.forDocument(documentId));
+    const history = pdf_viewer_controller_safely(()=>capabilities.history?.forDocument(documentId));
+    const zoomState = pdf_viewer_controller_safely(()=>zoom?.getState());
+    const searchState = pdf_viewer_controller_safely(()=>search?.getState());
+    return {
+        canRedo: pdf_viewer_controller_safely(()=>history?.canRedo()) ?? false,
+        canUndo: pdf_viewer_controller_safely(()=>history?.canUndo()) ?? false,
+        currentPage: pdf_viewer_controller_safely(()=>scroll?.getCurrentPage()) ?? 1,
+        documentOpen: true,
+        error: null,
+        features,
+        ready: true,
+        search: searchState ? {
+            active: searchState.active,
+            activeResultIndex: searchState.activeResultIndex,
+            error: false,
+            loading: searchState.loading,
+            query: searchState.query,
+            total: searchState.total
+        } : EMPTY_SEARCH,
+        totalPages: pdf_viewer_controller_safely(()=>scroll?.getTotalPages()) ?? 0,
+        zoomMode: 'string' == typeof zoomState?.zoomLevel ? zoomState.zoomLevel : null,
+        zoomPercent: Math.round((zoomState?.currentZoomLevel ?? 1) * 100)
+    };
+}
+function activeDocumentId(capabilities) {
+    return pdf_viewer_controller_safely(()=>capabilities?.documentManager?.getActiveDocumentId()) ?? null;
+}
+function withActiveDocument(capabilities, action) {
+    const documentId = activeDocumentId(capabilities);
+    if (!capabilities || !documentId) return;
+    pdf_viewer_controller_safely(()=>action(capabilities, documentId));
+}
+function requestPdfPageNavigation(scope, page, pendingPage) {
+    const totalPages = scope.getTotalPages();
+    if (totalPages < 1 || !Number.isFinite(page)) return;
+    const nextPage = Math.min(totalPages, Math.max(1, Math.round(page)));
+    const pageChangeInProgress = pdf_viewer_controller_safely(()=>scope.getPageChangeState().isChanging) ?? false;
+    if (pageChangeInProgress) {
+        pendingPage.current = nextPage;
+        return;
+    }
+    pendingPage.current = null;
+    scope.scrollToPage({
+        pageNumber: nextPage,
+        behavior: 'auto'
+    });
+}
+function pdf_viewer_controller_subscribe(unsubscribe, event, listener) {
+    if (!event) return;
+    const stop = pdf_viewer_controller_safely(()=>event(()=>listener()));
+    if (stop) unsubscribe.push(stop);
+}
+function pdf_viewer_controller_safely(read) {
+    try {
+        return read();
+    } catch  {
+        return;
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error && error.message ? error.message : 'PDF viewer initialization failed.';
+}
+const PDFIUM_WASM_PATH = '/vendor/embedpdf/pdfium.wasm';
+const PDF_VIEWER_READY_TIMEOUT_MS = 45000;
+const PDF_MOBILE_PAGE_NAVIGATION_QUERY = '(max-width: 640px)';
+const a3sPdfUiSchema = {
+    id: 'a3s-office-pdf',
+    version: '1',
+    toolbars: {},
+    menus: {},
+    sidebars: {},
+    modals: {},
+    overlays: {},
+    selectionMenus: {}
+};
+function PdfViewer({ fileName = 'document.pdf', loadSource, onSave, saveLabel = '保存', sourceKey, wasmUrl }) {
+    const [sourceUrl, setSourceUrl] = useState(null);
+    const [loadError, setLoadError] = useState(null);
+    const [saveState, setSaveState] = useState('idle');
+    const [retryCount, setRetryCount] = useState(0);
+    const [registry, setRegistry] = useState(null);
+    const [mobilePageNavigationOpen, setMobilePageNavigationOpen] = useState(false);
+    const pdfRootRef = useRef(null);
+    const searchInputRef = useRef(null);
+    const mobilePageNavigationId = useId();
+    const mobilePageNavigationToggleRef = useRef(null);
+    const mobilePageNavigationCloseRef = useRef(null);
+    const controller = usePdfViewerController(registry);
+    const annotation = usePdfAnnotationController(registry);
+    const viewerReady = controller.state.ready && controller.state.documentOpen;
+    const mobilePageNavigationModal = usePdfMobilePageNavigationModal();
+    const mobilePageNavigationModalOpen = mobilePageNavigationOpen && mobilePageNavigationModal;
+    const closeMobilePageNavigation = useCallback(()=>{
+        setMobilePageNavigationOpen(false);
+    }, []);
+    useDialogFocusScope({
+        active: mobilePageNavigationModalOpen,
+        onEscape: closeMobilePageNavigation,
+        initialFocus: ()=>mobilePageNavigationCloseRef.current,
+        getActiveScope: ()=>document.getElementById(mobilePageNavigationId),
+        getIsolationExceptions: ()=>[
+                document.querySelector('.work-pdf-page-navigation-backdrop')
+            ],
+        restoreFocusTarget: ()=>mobilePageNavigationModal ? mobilePageNavigationToggleRef.current : document.getElementById(mobilePageNavigationId)?.querySelector('[data-pdf-page-thumbnail][aria-current="page"]') ?? null
+    });
+    useEffect(()=>{
+        let disposed = false;
+        let objectUrl = null;
+        setRegistry(null);
+        setSaveState('idle');
+        setSourceUrl(null);
+        setLoadError(null);
+        setMobilePageNavigationOpen(false);
+        loadSource().then((source)=>{
+            if (disposed) return;
+            objectUrl = URL.createObjectURL('application/pdf' === source.type ? source : new Blob([
+                source
+            ], {
+                type: 'application/pdf'
+            }));
+            setSourceUrl(objectUrl);
+        }).catch((error)=>{
+            if (!disposed) setLoadError(pdfErrorMessage(error));
+        });
+        return ()=>{
+            disposed = true;
+            if (objectUrl) URL.revokeObjectURL(objectUrl);
+        };
+    }, [
+        loadSource,
+        retryCount,
+        sourceKey
+    ]);
+    useEffect(()=>{
+        if (controller.state.error) setLoadError(controller.state.error);
+    }, [
+        controller.state.error
+    ]);
+    useEffect(()=>{
+        if (!sourceUrl || viewerReady || loadError) return;
+        const timeout = window.setTimeout(()=>{
+            setRegistry(null);
+            setLoadError('PDF viewer initialization timed out.');
+        }, PDF_VIEWER_READY_TIMEOUT_MS);
+        return ()=>window.clearTimeout(timeout);
+    }, [
+        loadError,
+        sourceUrl,
+        viewerReady
+    ]);
+    const savePdf = useCallback(async ()=>{
+        if (!onSave || 'saving' === saveState) return;
+        setSaveState('saving');
+        try {
+            const saved = await onSave(await controller.saveAsCopy());
+            setSaveState(saved ? 'saved' : 'error');
+        } catch  {
+            setSaveState('error');
+        }
+    }, [
+        controller,
+        onSave,
+        saveState
+    ]);
+    const pdfExtensions = useMemo(createPdfEditorExtensions, []);
+    const pdfEditor = useOfficeEditorRuntime({
+        annotation,
+        editable: Boolean(onSave),
+        focusSearch: ()=>{
+            searchInputRef.current?.focus();
+            searchInputRef.current?.select();
+        },
+        save: {
+            enabled: Boolean(onSave) && 'saving' !== saveState,
+            execute: savePdf
+        },
+        viewer: controller
+    }, pdfExtensions);
+    const pdfCommands = pdfEditor.commands;
+    useOfficeEditorKeyboardShortcuts(pdfEditor, {
+        capture: true,
+        enabled: Boolean(sourceUrl),
+        scopeRef: pdfRootRef
+    });
+    useOfficeEditorWheelZoom({
+        enabled: Boolean(sourceUrl),
+        scopeRef: pdfRootRef,
+        onZoomIn: pdfCommands.zoomIn,
+        onZoomOut: pdfCommands.zoomOut
+    });
+    if (loadError) return /*#__PURE__*/ jsx(StateView, {
+        className: "work-pdf-state",
+        tone: "danger",
+        role: "alert",
+        icon: /*#__PURE__*/ jsx(AlertCircle, {
+            size: 24
+        }),
+        title: "无法打开 PDF",
+        description: "请重试。",
+        descriptionTitle: loadError,
+        actions: /*#__PURE__*/ jsx(button_Button, {
+            onClick: ()=>setRetryCount((value)=>value + 1),
+            children: "重试"
+        })
+    });
+    if (!sourceUrl) return /*#__PURE__*/ jsx(StateView, {
+        className: "work-pdf-state",
+        role: "status",
+        icon: /*#__PURE__*/ jsx(Loader2, {
+            className: "spin",
+            size: 22
+        }),
+        title: "正在加载 PDF…"
+    });
+    return /*#__PURE__*/ jsxs("section", {
+        ref: pdfRootRef,
+        className: "work-pdf-viewer",
+        "aria-label": `PDF 编辑器：${fileName}`,
+        children: [
+            /*#__PURE__*/ jsx(PdfToolbar, {
+                annotationState: annotation.state,
+                can: pdfEditor.can(),
+                commands: pdfCommands,
+                editable: Boolean(onSave),
+                pageNavigation: viewerReady && registry && controller.state.totalPages > 0 ? {
+                    controlsId: mobilePageNavigationId,
+                    expanded: mobilePageNavigationOpen,
+                    onOpen: ()=>setMobilePageNavigationOpen(true),
+                    toggleRef: mobilePageNavigationToggleRef
+                } : void 0,
+                searchInputRef: searchInputRef,
+                saveLabel: saveLabel,
+                saveState: saveState,
+                state: controller.state
+            }),
+            /*#__PURE__*/ jsxs("div", {
+                className: "work-pdf-workspace",
+                "data-mobile-page-navigation": mobilePageNavigationOpen ? 'open' : 'closed',
+                children: [
+                    viewerReady && registry && controller.state.totalPages > 0 && /*#__PURE__*/ jsx(PdfThumbnailRail, {
+                        currentPage: controller.state.currentPage,
+                        mobileCloseButtonRef: mobilePageNavigationCloseRef,
+                        mobileNavigationId: mobilePageNavigationId,
+                        mobileNavigationModal: mobilePageNavigationModalOpen,
+                        registry: registry,
+                        totalPages: controller.state.totalPages,
+                        onCloseMobileNavigation: closeMobilePageNavigation,
+                        onSelectPage: (page)=>{
+                            controller.goToPage(page);
+                            if (mobilePageNavigationModalOpen) closeMobilePageNavigation();
+                        }
+                    }),
+                    mobilePageNavigationModalOpen && /*#__PURE__*/ jsx("button", {
+                        type: "button",
+                        className: "work-pdf-page-navigation-backdrop",
+                        "aria-label": "关闭 PDF 页面导航遮罩",
+                        tabIndex: -1,
+                        onClick: closeMobilePageNavigation
+                    }),
+                    /*#__PURE__*/ jsxs("div", {
+                        className: "work-pdf-embed",
+                        "aria-busy": !viewerReady,
+                        "data-ready": viewerReady || void 0,
+                        children: [
+                            /*#__PURE__*/ jsx(PDFViewer, {
+                                className: "work-pdf-native-viewer",
+                                style: {
+                                    width: '100%',
+                                    height: '100%'
+                                },
+                                config: {
+                                    src: sourceUrl,
+                                    wasmUrl: wasmUrl ?? new URL(PDFIUM_WASM_PATH, window.location.href).href,
+                                    tabBar: 'never',
+                                    theme: {
+                                        preference: 'system',
+                                        light: {
+                                            accent: {
+                                                primary: '#2867d8'
+                                            }
+                                        },
+                                        dark: {
+                                            accent: {
+                                                primary: '#7da7ff'
+                                            }
+                                        }
+                                    },
+                                    i18n: {
+                                        defaultLocale: 'zh-CN'
+                                    },
+                                    ui: {
+                                        schema: a3sPdfUiSchema
+                                    },
+                                    thumbnails: {
+                                        autoScroll: false,
+                                        buffer: 4,
+                                        gap: 10,
+                                        imagePadding: 0,
+                                        labelHeight: 0,
+                                        paddingY: 0,
+                                        width: 132
+                                    },
+                                    annotations: {
+                                        annotationAuthor: 'A3S Office 用户',
+                                        autoCommit: true
+                                    },
+                                    export: {
+                                        defaultFileName: fileName
+                                    },
+                                    fonts: {
+                                        ui: null,
+                                        signature: null
+                                    },
+                                    disabledCategories: onSave ? void 0 : [
+                                        'annotation',
+                                        'redaction',
+                                        'form',
+                                        'history'
+                                    ]
+                                },
+                                onReady: setRegistry
+                            }, sourceUrl),
+                            !viewerReady && /*#__PURE__*/ jsxs("div", {
+                                className: "work-pdf-loading",
+                                role: "status",
+                                children: [
+                                    /*#__PURE__*/ jsx(Loader2, {
+                                        className: "spin",
+                                        size: 18
+                                    }),
+                                    "正在打开…"
+                                ]
+                            })
+                        ]
+                    })
+                ]
+            })
+        ]
+    });
+}
+function pdfErrorMessage(error) {
+    if (error instanceof Error && error.message) return error.message;
+    return 'Unable to read this PDF file.';
+}
+function usePdfMobilePageNavigationModal() {
+    const [matches, setMatches] = useState(()=>pdfMediaQueryMatches(PDF_MOBILE_PAGE_NAVIGATION_QUERY));
+    useEffect(()=>{
+        if ("u" < typeof window || 'function' != typeof window.matchMedia) return;
+        const mediaQuery = window.matchMedia(PDF_MOBILE_PAGE_NAVIGATION_QUERY);
+        const update = ()=>setMatches(mediaQuery.matches);
+        update();
+        if ('function' == typeof mediaQuery.addEventListener) {
+            mediaQuery.addEventListener('change', update);
+            return ()=>mediaQuery.removeEventListener('change', update);
+        }
+        mediaQuery.addListener(update);
+        return ()=>mediaQuery.removeListener(update);
+    }, []);
+    return matches;
+}
+function pdfMediaQueryMatches(query) {
+    if ("u" < typeof window || 'function' != typeof window.matchMedia) return true;
+    return window.matchMedia(query).matches;
+}
+export { pdf_viewer_namespaceObject };