@a3s-lab/office 0.32.0 → 0.34.0

package/dist/0~pdf-viewer.js

@@ -1,13 +1,13 @@
 import { __webpack_require__ } from "./0~rslib-runtime.js";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { AnnotationPlugin, DocumentManagerPlugin, ExportPlugin, FormPlugin, HistoryPlugin, PDFViewer, PdfAnnotationSubtype, ScrollPlugin, SearchPlugin, ThumbnailPlugin, ViewportPlugin, 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 { AlertCircle, Check, ChevronDown, ChevronLeft, ChevronRight, ChevronUp, Download, Ellipsis, FilePlus2, Files, GalleryVerticalEnd, Highlighter, LayoutGrid, Loader2, Minus, MousePointer2, MoveHorizontal, Pencil, Plus, Redo2, RotateCcw, RotateCw, Save, Scan, Scissors, Search, SlidersHorizontal, Strikethrough, Trash2, Type, Underline, Undo2, X } from "lucide-react";
 import { useCallback, useEffect, useId, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { PdfErrorCode } from "@embedpdf/models";
 import { readOfficePdfCollaborationSource as readWorkOfficePdfCollaborationSource, createOfficePdfCollaborationBinding as createWorkOfficePdfCollaborationBinding, assertPdfCollaborationSource as assertWorkOfficePdfCollaborationSource } from "./3818.js";
 import { createOfficeEditorExtension, useOfficeEditorRuntime, useOfficeEditorKeyboardShortcuts } from "./0~3557.js";
 import { isOfficeShortcutBlocked, OfficeColorPicker } from "./0~3635.js";
-import { officePresenceColorStyle, moveOfficeMenuFocus, useOfficeRemoteParticipants, WorkOfficeCollaborationParticipants, Popover, OfficePresenceAvatar, useOfficePublishPresenceLocation, button_Button, icon_button_IconButton, office_text_field_OfficeTextField, useDialogFocusScope, useOfficeEditorWheelZoom } from "./0~6090.js";
+import { officePresenceColorStyle, moveOfficeMenuFocus, useOfficeEditorWheelZoom, useOfficeRemoteParticipants, WorkOfficeCollaborationParticipants, Dialog, OfficePresenceAvatar, useOfficePublishPresenceLocation, button_Button, icon_button_IconButton, office_text_field_OfficeTextField, Popover, useDialogFocusScope, office_text_field_OfficeFileInput } from "./0~8136.js";
 import { StateView, useOfficeCollaborationLocationNavigator, PDF_EVIDENCE_COORDINATE_BASIS } from "./432.js";
 var pdf_viewer_namespaceObject = {};
 __webpack_require__.r(pdf_viewer_namespaceObject);
@@ -714,6 +714,83 @@ function sortPdfJson(value) {
             sortPdfJson(child)
         ]));
 }
+const PDF_PAGE_ORGANIZATION_MAX_SOURCE_BYTES = 268435456;
+const PDF_PAGE_ORGANIZATION_MAX_IMPORT_BYTES = 134217728;
+class PdfPageOrganizationError extends Error {
+    code;
+    constructor(code, message){
+        super(message);
+        this.name = 'PdfPageOrganizationError';
+        this.code = code;
+    }
+}
+function validatedPdfPageIndexes(pageIndexes, pageCount, options = {}) {
+    if (!Array.isArray(pageIndexes) || !options.allowEmpty && 0 === pageIndexes.length) throw new PdfPageOrganizationError('pdf.pages.invalid-index', 'Select at least one PDF page.');
+    const seen = new Set();
+    for (const pageIndex of pageIndexes){
+        if (!Number.isSafeInteger(pageIndex) || pageIndex < 0 || pageIndex >= pageCount) throw new PdfPageOrganizationError('pdf.pages.invalid-index', `Page index ${String(pageIndex)} is outside the current ${pageCount}-page PDF.`);
+        if (seen.has(pageIndex)) throw new PdfPageOrganizationError('pdf.pages.duplicate-index', `Page index ${pageIndex} appears more than once.`);
+        seen.add(pageIndex);
+    }
+    const result = [
+        ...pageIndexes
+    ];
+    return options.preserveOrder ? result : result.sort((left, right)=>left - right);
+}
+function validatedPdfPageOrder(pageOrder, pageCount) {
+    if (!Array.isArray(pageOrder) || pageOrder.length !== pageCount) throw invalidOrder(pageCount);
+    try {
+        const order = validatedPdfPageIndexes(pageOrder, pageCount, {
+            preserveOrder: true
+        });
+        if (order.length === pageCount) return order;
+    } catch  {}
+    throw invalidOrder(pageCount);
+}
+function reorderedPdfPageIndexes(pageCount, pageIndexes, targetIndex) {
+    const selected = validatedPdfPageIndexes(pageIndexes, pageCount);
+    if (!Number.isSafeInteger(targetIndex) || targetIndex < 0 || targetIndex > pageCount) throw new PdfPageOrganizationError('pdf.pages.invalid-index', `Insertion gap ${String(targetIndex)} is outside the current ${pageCount}-page PDF.`);
+    const selectedSet = new Set(selected);
+    const remaining = Array.from({
+        length: pageCount
+    }, (_, index)=>index).filter((index)=>!selectedSet.has(index));
+    const removedBeforeTarget = selected.filter((index)=>index < targetIndex).length;
+    const insertionIndex = Math.max(0, Math.min(remaining.length, targetIndex - removedBeforeTarget));
+    remaining.splice(insertionIndex, 0, ...selected);
+    return remaining;
+}
+function validatedPdfInsertionIndex(index, pageCount) {
+    if (!Number.isSafeInteger(index) || index < 0 || index > pageCount) throw new PdfPageOrganizationError('pdf.pages.invalid-index', `Insertion gap ${String(index)} is outside the current ${pageCount}-page PDF.`);
+    return index;
+}
+function validatedPdfPageSize(size) {
+    const candidate = size ?? {
+        height: 841.89,
+        width: 595.28
+    };
+    if (!Number.isFinite(candidate.width) || !Number.isFinite(candidate.height) || candidate.width < 18 || candidate.height < 18 || candidate.width > 14400 || candidate.height > 14400) throw new PdfPageOrganizationError('pdf.pages.invalid-page-size', "PDF page dimensions must be between 18 and 14400 points.");
+    return {
+        height: candidate.height,
+        width: candidate.width
+    };
+}
+function validatedPdfSplitBoundaries(splitAfterPageIndexes, pageCount) {
+    if (!Array.isArray(splitAfterPageIndexes) || 0 === splitAfterPageIndexes.length) throw invalidSplit(pageCount);
+    let previous = -1;
+    for (const pageIndex of splitAfterPageIndexes){
+        if (!Number.isSafeInteger(pageIndex) || pageIndex < 0 || pageIndex >= pageCount - 1 || pageIndex <= previous) throw invalidSplit(pageCount);
+        previous = pageIndex;
+    }
+    return [
+        ...splitAfterPageIndexes
+    ];
+}
+function invalidOrder(pageCount) {
+    return new PdfPageOrganizationError('pdf.pages.invalid-order', `A page order must contain every index from 0 through ${Math.max(0, pageCount - 1)} exactly once.`);
+}
+function invalidSplit(pageCount) {
+    return new PdfPageOrganizationError('pdf.pages.invalid-split', `Split boundaries must be unique, ascending, and before the last page of the ${pageCount}-page PDF.`);
+}
 function createPdfEditorExtensions() {
     return [
         createOfficeEditorExtension({
@@ -822,6 +899,65 @@ function createPdfEditorExtensions() {
                     }
                 })
         }),
+        createOfficeEditorExtension({
+            name: 'pdfPageOrganization',
+            addCommands: ()=>({
+                    deletePages: {
+                        canExecute: (context, pageIndexes)=>canOrganizeSelectedPages(context, pageIndexes) && pageIndexes.length < context.viewer.state.totalPages,
+                        execute: ({ pages }, pageIndexes)=>pages.mutate({
+                                kind: 'delete',
+                                pageIndexes
+                            })
+                    },
+                    extractPages: {
+                        canExecute: canOrganizeSelectedPages,
+                        execute: ({ pages }, pageIndexes)=>pages.exportPages({
+                                kind: 'extract',
+                                pageIndexes
+                            })
+                    },
+                    insertBlankPage: {
+                        canExecute: (context, index)=>canOrganizePages(context) && safelyValidate(()=>validatedPdfInsertionIndex(index, context.viewer.state.totalPages)),
+                        execute: ({ pages }, index)=>pages.mutate({
+                                index,
+                                kind: 'insert-blank'
+                            })
+                    },
+                    mergePages: {
+                        canExecute: (context, index, source)=>canOrganizePages(context) && source instanceof Blob && source.size > 0 && safelyValidate(()=>validatedPdfInsertionIndex(index, context.viewer.state.totalPages)),
+                        execute: ({ pages }, index, source)=>pages.mutate({
+                                index,
+                                kind: 'merge'
+                            }, source)
+                    },
+                    openPageOrganizer: {
+                        canExecute: canOrganizePages,
+                        execute: ({ openPageOrganizer })=>openPageOrganizer()
+                    },
+                    reorderPages: {
+                        canExecute: (context, pageOrder)=>canOrganizePages(context) && safelyValidate(()=>validatedPdfPageOrder(pageOrder, context.viewer.state.totalPages)),
+                        execute: ({ pages }, pageOrder)=>pages.mutate({
+                                kind: 'reorder',
+                                pageOrder
+                            })
+                    },
+                    rotatePages: {
+                        canExecute: (context, pageIndexes, degrees)=>canOrganizeSelectedPages(context, pageIndexes) && (90 === degrees || 180 === degrees || 270 === degrees),
+                        execute: ({ pages }, pageIndexes, degrees)=>pages.mutate({
+                                degrees,
+                                kind: 'rotate',
+                                pageIndexes
+                            })
+                    },
+                    splitPages: {
+                        canExecute: (context, splitAfterPageIndexes)=>canOrganizePages(context) && safelyValidate(()=>validatedPdfSplitBoundaries(splitAfterPageIndexes, context.viewer.state.totalPages)),
+                        execute: ({ pages }, splitAfterPageIndexes)=>pages.exportPages({
+                                kind: 'split',
+                                splitAfterPageIndexes
+                            })
+                    }
+                })
+        }),
         createOfficeEditorExtension({
             name: 'pdfKeyboardShortcuts',
             addKeyboardShortcuts: ()=>({
@@ -879,6 +1015,20 @@ function canSearch(viewer) {
 function canZoom(viewer) {
     return documentReady(viewer) && viewer.state.features.zoom;
 }
+function canOrganizePages(context) {
+    return context.editable && documentReady(context.viewer) && context.pages.state.available && !context.pages.state.busy;
+}
+function canOrganizeSelectedPages(context, pageIndexes) {
+    return canOrganizePages(context) && safelyValidate(()=>validatedPdfPageIndexes(pageIndexes, context.viewer.state.totalPages));
+}
+function safelyValidate(validate) {
+    try {
+        validate();
+        return true;
+    } catch  {
+        return false;
+    }
+}
 function canSave({ editable, save, viewer }) {
     return editable && save.enabled && documentReady(viewer) && viewer.state.features.export;
 }
@@ -1538,6 +1688,381 @@ function pdfThumbnailKeyboardPage(key, page, totalPages) {
     if ('ArrowDown' === key || 'ArrowRight' === key) return Math.min(totalPages, page + 1);
     return null;
 }
+const PDF_ORGANIZER_ITEM_HEIGHT = 184;
+const PDF_ORGANIZER_VIEWPORT_HEIGHT = 552;
+function PdfPageOrganizerDialog({ busy, can, commands, currentPage, diagnostics, error, registry, restoreFocusTarget, totalPages, onClose, onDismissError }) {
+    const initialIndex = Math.min(Math.max(0, totalPages - 1), Math.max(0, currentPage - 1));
+    const [selected, setSelected] = useState(()=>new Set([
+            initialIndex
+        ]));
+    const [anchorIndex, setAnchorIndex] = useState(initialIndex);
+    const [submitting, setSubmitting] = useState(false);
+    const selectionAnchorRef = useRef(initialIndex);
+    const mergeInputRef = useRef(null);
+    const effectiveBusy = busy || submitting;
+    const selectedIndexes = useMemo(()=>[
+            ...selected
+        ].sort((left, right)=>left - right), [
+        selected
+    ]);
+    const range = useMemo(()=>calculatePdfThumbnailRange({
+            anchorIndex,
+            itemHeight: PDF_ORGANIZER_ITEM_HEIGHT,
+            totalPages,
+            viewportHeight: PDF_ORGANIZER_VIEWPORT_HEIGHT
+        }), [
+        anchorIndex,
+        totalPages
+    ]);
+    const visibleIndexes = useMemo(()=>Array.from({
+            length: Math.max(0, range.end - range.start)
+        }, (_, index)=>range.start + index), [
+        range.end,
+        range.start
+    ]);
+    const insertionIndex = selectedIndexes.length > 0 ? Math.min(totalPages, (selectedIndexes.at(-1) ?? 0) + 1) : totalPages;
+    const splitBoundaries = selectedIndexes.filter((pageIndex)=>pageIndex < totalPages - 1);
+    const moveLeftOrder = pageMoveOrder(totalPages, selectedIndexes, 'left');
+    const moveRightOrder = pageMoveOrder(totalPages, selectedIndexes, 'right');
+    const commitMutation = async (execute)=>{
+        if (effectiveBusy) return;
+        setSubmitting(true);
+        const applied = await execute();
+        if (applied) onClose();
+        else setSubmitting(false);
+    };
+    const runExport = async (execute)=>{
+        if (effectiveBusy) return;
+        setSubmitting(true);
+        await execute();
+        setSubmitting(false);
+    };
+    return /*#__PURE__*/ jsxs(Dialog, {
+        title: "组织 PDF 页面",
+        description: "选择页面后插入、删除、旋转、重排、抽取、合并或拆分。",
+        className: "work-pdf-page-organizer-dialog",
+        closeDisabled: effectiveBusy,
+        restoreFocusTarget: restoreFocusTarget,
+        onClose: onClose,
+        footer: /*#__PURE__*/ jsx(button_Button, {
+            tone: "primary",
+            disabled: effectiveBusy,
+            onClick: onClose,
+            children: "完成"
+        }),
+        children: [
+            /*#__PURE__*/ jsx(office_text_field_OfficeFileInput, {
+                ref: mergeInputRef,
+                accept: ".pdf,application/pdf",
+                "aria-label": "选择要合并的 PDF",
+                disabled: effectiveBusy,
+                onFileSelect: (file)=>{
+                    if (!can.mergePages(insertionIndex, file)) return;
+                    commitMutation(()=>commands.mergePages(insertionIndex, file));
+                }
+            }),
+            /*#__PURE__*/ jsxs("div", {
+                className: "work-pdf-page-organizer-actions",
+                role: "toolbar",
+                "aria-label": "PDF 页面组织命令",
+                children: [
+                    /*#__PURE__*/ jsxs(button_Button, {
+                        tone: "secondary",
+                        "aria-label": "插入空白页",
+                        disabled: !can.insertBlankPage(insertionIndex) || effectiveBusy,
+                        onClick: ()=>void commitMutation(()=>commands.insertBlankPage(insertionIndex)),
+                        children: [
+                            /*#__PURE__*/ jsx(FilePlus2, {
+                                size: 15
+                            }),
+                            " 插入空白页"
+                        ]
+                    }),
+                    /*#__PURE__*/ jsxs(button_Button, {
+                        tone: "secondary",
+                        "aria-label": "合并另一个 PDF",
+                        disabled: effectiveBusy,
+                        onClick: ()=>mergeInputRef.current?.click(),
+                        children: [
+                            /*#__PURE__*/ jsx(Files, {
+                                size: 15
+                            }),
+                            " 合并 PDF"
+                        ]
+                    }),
+                    /*#__PURE__*/ jsxs(button_Button, {
+                        tone: "secondary",
+                        "aria-label": "前移所选页",
+                        disabled: !moveLeftOrder || !can.reorderPages(moveLeftOrder) || effectiveBusy,
+                        onClick: ()=>{
+                            if (moveLeftOrder) commitMutation(()=>commands.reorderPages(moveLeftOrder));
+                        },
+                        children: [
+                            /*#__PURE__*/ jsx(ChevronLeft, {
+                                size: 15
+                            }),
+                            " 前移"
+                        ]
+                    }),
+                    /*#__PURE__*/ jsxs(button_Button, {
+                        tone: "secondary",
+                        "aria-label": "后移所选页",
+                        disabled: !moveRightOrder || !can.reorderPages(moveRightOrder) || effectiveBusy,
+                        onClick: ()=>{
+                            if (moveRightOrder) commitMutation(()=>commands.reorderPages(moveRightOrder));
+                        },
+                        children: [
+                            /*#__PURE__*/ jsx(ChevronRight, {
+                                size: 15
+                            }),
+                            " 后移"
+                        ]
+                    }),
+                    /*#__PURE__*/ jsxs(button_Button, {
+                        tone: "secondary",
+                        "aria-label": "向左旋转所选页",
+                        disabled: !can.rotatePages(selectedIndexes, 270) || effectiveBusy,
+                        onClick: ()=>void commitMutation(()=>commands.rotatePages(selectedIndexes, 270)),
+                        children: [
+                            /*#__PURE__*/ jsx(RotateCcw, {
+                                size: 15
+                            }),
+                            " 左转"
+                        ]
+                    }),
+                    /*#__PURE__*/ jsxs(button_Button, {
+                        tone: "secondary",
+                        "aria-label": "向右旋转所选页",
+                        disabled: !can.rotatePages(selectedIndexes, 90) || effectiveBusy,
+                        onClick: ()=>void commitMutation(()=>commands.rotatePages(selectedIndexes, 90)),
+                        children: [
+                            /*#__PURE__*/ jsx(RotateCw, {
+                                size: 15
+                            }),
+                            " 右转"
+                        ]
+                    }),
+                    /*#__PURE__*/ jsxs(button_Button, {
+                        tone: "secondary",
+                        "aria-label": "抽取所选页",
+                        disabled: !can.extractPages(selectedIndexes) || effectiveBusy,
+                        onClick: ()=>void runExport(()=>commands.extractPages(selectedIndexes)),
+                        children: [
+                            /*#__PURE__*/ jsx(Download, {
+                                size: 15
+                            }),
+                            " 抽取"
+                        ]
+                    }),
+                    /*#__PURE__*/ jsxs(button_Button, {
+                        tone: "secondary",
+                        "aria-label": "在所选页后拆分",
+                        disabled: !can.splitPages(splitBoundaries) || effectiveBusy,
+                        onClick: ()=>void runExport(()=>commands.splitPages(splitBoundaries)),
+                        children: [
+                            /*#__PURE__*/ jsx(Scissors, {
+                                size: 15
+                            }),
+                            " 拆分"
+                        ]
+                    }),
+                    /*#__PURE__*/ jsxs(button_Button, {
+                        tone: "danger",
+                        "aria-label": "删除所选页",
+                        disabled: !can.deletePages(selectedIndexes) || effectiveBusy,
+                        onClick: ()=>void commitMutation(()=>commands.deletePages(selectedIndexes)),
+                        children: [
+                            /*#__PURE__*/ jsx(Trash2, {
+                                size: 15
+                            }),
+                            " 删除"
+                        ]
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsxs("div", {
+                className: "work-pdf-page-organizer-selection",
+                children: [
+                    /*#__PURE__*/ jsxs("output", {
+                        "aria-live": "polite",
+                        children: [
+                            "已选择 ",
+                            selectedIndexes.length,
+                            " / ",
+                            totalPages,
+                            " 页"
+                        ]
+                    }),
+                    /*#__PURE__*/ jsx("button", {
+                        type: "button",
+                        disabled: effectiveBusy,
+                        onClick: ()=>setSelected(new Set(Array.from({
+                                length: totalPages
+                            }, (_, index)=>index))),
+                        children: "全选"
+                    }),
+                    /*#__PURE__*/ jsx("button", {
+                        type: "button",
+                        disabled: effectiveBusy,
+                        onClick: ()=>setSelected(new Set([
+                                initialIndex
+                            ])),
+                        children: "仅当前页"
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsx("section", {
+                className: "work-pdf-page-organizer-viewport",
+                "aria-label": "可重排 PDF 页面",
+                onScroll: (event)=>setAnchorIndex(Math.floor(event.currentTarget.scrollTop / PDF_ORGANIZER_ITEM_HEIGHT)),
+                children: /*#__PURE__*/ jsxs("div", {
+                    className: "work-pdf-page-organizer-list",
+                    children: [
+                        /*#__PURE__*/ jsx(OrganizerSpacer, {
+                            height: range.start * PDF_ORGANIZER_ITEM_HEIGHT
+                        }),
+                        visibleIndexes.map((pageIndex)=>/*#__PURE__*/ jsx(OrganizerPage, {
+                                current: pageIndex === initialIndex,
+                                pageIndex: pageIndex,
+                                registry: registry,
+                                selected: selected.has(pageIndex),
+                                disabled: effectiveBusy,
+                                onDrop: (targetIndex)=>{
+                                    const order = reorderedPdfPageIndexes(totalPages, selectedIndexes, targetIndex);
+                                    if (can.reorderPages(order)) commitMutation(()=>commands.reorderPages(order));
+                                },
+                                onSelect: (event)=>{
+                                    setSelected((current)=>nextPageSelection(current, pageIndex, selectionAnchorRef.current, event));
+                                    if (!event.shiftKey) selectionAnchorRef.current = pageIndex;
+                                }
+                            }, pageIndex)),
+                        /*#__PURE__*/ jsx(OrganizerSpacer, {
+                            height: Math.max(0, totalPages - range.end) * PDF_ORGANIZER_ITEM_HEIGHT
+                        })
+                    ]
+                })
+            }),
+            error && /*#__PURE__*/ jsxs("div", {
+                className: "work-pdf-page-organizer-error",
+                role: "alert",
+                children: [
+                    /*#__PURE__*/ jsxs("div", {
+                        children: [
+                            /*#__PURE__*/ jsx("strong", {
+                                children: "无法安全完成页面操作"
+                            }),
+                            /*#__PURE__*/ jsx("p", {
+                                children: error.message
+                            }),
+                            /*#__PURE__*/ jsx("code", {
+                                children: error.code
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ jsx("button", {
+                        type: "button",
+                        "aria-label": "关闭错误提示",
+                        onClick: onDismissError,
+                        children: "\xd7"
+                    })
+                ]
+            }),
+            diagnostics.length > 0 && /*#__PURE__*/ jsx("ul", {
+                className: "work-pdf-page-organizer-diagnostics",
+                role: "status",
+                children: diagnostics.map((diagnostic)=>/*#__PURE__*/ jsx("li", {
+                        children: diagnostic.message
+                    }, diagnostic.code))
+            }),
+            /*#__PURE__*/ jsx("p", {
+                className: "work-pdf-page-organizer-boundary",
+                children: "页面操作在 Worker 中生成新 PDF，并由一个撤销记录恢复。签名、加密、表单、目录或标记结构无法安全重写时会明确停止。"
+            })
+        ]
+    });
+}
+function OrganizerPage({ current, disabled, pageIndex, registry, selected, onDrop, onSelect }) {
+    const { sourceUrl, state } = usePdfThumbnailSource(registry, pageIndex + 1);
+    return /*#__PURE__*/ jsxs("button", {
+        type: "button",
+        className: selected ? 'selected' : void 0,
+        "aria-current": current ? 'page' : void 0,
+        "aria-label": `选择第 ${pageIndex + 1} 页`,
+        "aria-pressed": selected,
+        "data-pdf-organizer-page-index": pageIndex,
+        disabled: disabled,
+        draggable: !disabled,
+        onClick: onSelect,
+        onDragOver: (event)=>{
+            event.preventDefault();
+            event.dataTransfer.dropEffect = 'move';
+        },
+        onDragStart: (event)=>{
+            event.dataTransfer.effectAllowed = 'move';
+            event.dataTransfer.setData('text/plain', String(pageIndex));
+        },
+        onDrop: (event)=>{
+            event.preventDefault();
+            onDrop(pageIndex);
+        },
+        children: [
+            /*#__PURE__*/ jsxs("span", {
+                className: "work-pdf-page-organizer-number",
+                children: [
+                    pageIndex + 1,
+                    current && /*#__PURE__*/ jsx("small", {
+                        children: "当前"
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsx("span", {
+                className: "work-pdf-page-organizer-preview",
+                "data-state": state,
+                children: sourceUrl && /*#__PURE__*/ jsx("img", {
+                    src: sourceUrl,
+                    alt: "",
+                    draggable: false
+                })
+            })
+        ]
+    });
+}
+function nextPageSelection(current, pageIndex, anchorIndex, event) {
+    if (event.shiftKey) {
+        const start = Math.min(anchorIndex, pageIndex);
+        const end = Math.max(anchorIndex, pageIndex);
+        return new Set(Array.from({
+            length: end - start + 1
+        }, (_, index)=>start + index));
+    }
+    if (event.metaKey || event.ctrlKey) {
+        const next = new Set(current);
+        if (next.has(pageIndex)) next.delete(pageIndex);
+        else next.add(pageIndex);
+        return next;
+    }
+    return new Set([
+        pageIndex
+    ]);
+}
+function pageMoveOrder(pageCount, selected, direction) {
+    if (0 === selected.length) return null;
+    if ('left' === direction) {
+        const first = selected[0] ?? 0;
+        return first <= 0 ? null : reorderedPdfPageIndexes(pageCount, selected, first - 1);
+    }
+    const last = selected.at(-1) ?? pageCount - 1;
+    return last >= pageCount - 1 ? null : reorderedPdfPageIndexes(pageCount, selected, last + 2);
+}
+function OrganizerSpacer({ height }) {
+    if (height <= 0) return null;
+    return /*#__PURE__*/ jsx("span", {
+        "aria-hidden": "true",
+        style: {
+            height
+        }
+    });
+}
 function StatusBadge({ tone = 'neutral', children, className = '' }) {
     return /*#__PURE__*/ jsx("span", {
         className: `ds-status-badge ${tone}${className ? ` ${className}` : ''}`,
@@ -1554,8 +2079,9 @@ const pdfKeyboardShortcuts = {
     zoomIn: 'Control+= Meta+= Control+Shift++ Meta+Shift++',
     zoomOut: 'Control+- Meta+-'
 };
-function PdfToolbar({ annotationState, can, commands, editable, pageNavigation, saveAvailable, saveLabel, saveState, searchInputRef, state }) {
+function PdfToolbar({ annotationState, can, commands, editable, pageOrganizationAvailable, pageNavigation, saveAvailable, saveLabel, saveState, searchInputRef, state }) {
     const showSave = saveAvailable ?? editable;
+    const showPageOrganization = pageOrganizationAvailable ?? editable;
     const [pageValue, setPageValue] = useState('');
     const [searchValue, setSearchValue] = useState('');
     const cancelPageBlurCommitRef = useRef(false);
@@ -1662,6 +2188,27 @@ function PdfToolbar({ annotationState, can, commands, editable, pageNavigation,
                     })
                 ]
             }),
+            showPageOrganization && /*#__PURE__*/ jsx("div", {
+                className: "work-pdf-toolbar-group work-pdf-page-organization",
+                children: /*#__PURE__*/ jsxs(button_Button, {
+                    tone: "secondary",
+                    className: "work-pdf-page-organizer-trigger",
+                    "data-pdf-page-organizer-trigger": true,
+                    "aria-label": "组织 PDF 页面",
+                    title: "组织 PDF 页面",
+                    disabled: !can.openPageOrganizer(),
+                    onClick: commands.openPageOrganizer,
+                    children: [
+                        /*#__PURE__*/ jsx(LayoutGrid, {
+                            size: 15
+                        }),
+                        /*#__PURE__*/ jsx("span", {
+                            className: "work-pdf-page-organizer-label",
+                            children: "组织页面"
+                        })
+                    ]
+                })
+            }),
             editable && /*#__PURE__*/ jsxs("fieldset", {
                 className: "work-pdf-toolbar-group work-pdf-annotation",
                 children: [
@@ -1759,6 +2306,7 @@ function PdfToolbar({ annotationState, can, commands, editable, pageNavigation,
                 can: can,
                 commands: commands,
                 editable: editable,
+                pageOrganizationAvailable: showPageOrganization,
                 state: state
             }),
             /*#__PURE__*/ jsx("search", {
@@ -2104,7 +2652,7 @@ function movePdfAnnotationStyleOption(event) {
     });
     next?.click();
 }
-function PdfToolbarOverflow({ annotationState, can, commands, editable, state }) {
+function PdfToolbarOverflow({ annotationState, can, commands, editable, pageOrganizationAvailable, 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 工具",
@@ -2254,6 +2802,18 @@ function PdfToolbarOverflow({ annotationState, can, commands, editable, state })
                             })
                         ]
                     }),
+                    pageOrganizationAvailable && /*#__PURE__*/ jsx("fieldset", {
+                        className: "work-pdf-overflow-group",
+                        "aria-label": "页面组织",
+                        children: /*#__PURE__*/ jsx(PdfOverflowAction, {
+                            label: "组织页面",
+                            disabled: !can.openPageOrganizer(),
+                            onSelect: ()=>select(commands.openPageOrganizer),
+                            children: /*#__PURE__*/ jsx(LayoutGrid, {
+                                size: 15
+                            })
+                        })
+                    }),
                     state.features.navigation && /*#__PURE__*/ jsxs("fieldset", {
                         className: "work-pdf-overflow-group",
                         "aria-label": "翻页",
@@ -2740,6 +3300,357 @@ function pdf_viewer_controller_safely(read) {
 function errorMessage(error) {
     return error instanceof Error && error.message ? error.message : 'PDF viewer initialization failed.';
 }
+const PDF_PAGE_ORGANIZATION_WORKER_TIMEOUT_MS = 120000;
+async function runPdfPageOrganizationJob(job, signal) {
+    if (signal?.aborted) throw pdfPageOrganizationAbortError();
+    if ("u" < typeof Worker) return runDirectly(job, signal);
+    let worker;
+    try {
+        worker = new Worker(new URL('./pdf-page-organization.worker.js', import.meta.url), {
+            name: 'a3s-office-pdf-page-organization'
+        });
+    } catch  {
+        return runDirectly(job, signal);
+    }
+    return new Promise((resolve, reject)=>{
+        let settled = false;
+        const timeout = setTimeout(()=>{
+            finish(void 0, new PdfPageOrganizationError('pdf.pages.invalid-source', 'PDF page organization timed out.'));
+        }, PDF_PAGE_ORGANIZATION_WORKER_TIMEOUT_MS);
+        const finish = (result, error)=>{
+            if (settled) return;
+            settled = true;
+            clearTimeout(timeout);
+            signal?.removeEventListener('abort', handleAbort);
+            worker.removeEventListener('error', handleWorkerError);
+            worker.removeEventListener('message', handleMessage);
+            worker.removeEventListener('messageerror', handleWorkerError);
+            worker.terminate();
+            if (error) reject(error);
+            else if (result) resolve(result);
+            else reject(new Error('PDF page worker returned no result.'));
+        };
+        const handleAbort = ()=>finish(void 0, pdfPageOrganizationAbortError());
+        const handleWorkerError = ()=>finish(void 0, new PdfPageOrganizationError('pdf.pages.invalid-source', 'The PDF page worker failed before producing a result.'));
+        const handleMessage = (event)=>{
+            const response = event.data;
+            if (!response || 'object' != typeof response) return void handleWorkerError();
+            if ('failure' === response.kind) return void finish(void 0, new PdfPageOrganizationError(response.code, response.message));
+            if ('success' === response.kind) finish(response.result);
+            else handleWorkerError();
+        };
+        signal?.addEventListener('abort', handleAbort, {
+            once: true
+        });
+        worker.addEventListener('error', handleWorkerError, {
+            once: true
+        });
+        worker.addEventListener('message', handleMessage);
+        worker.addEventListener('messageerror', handleWorkerError, {
+            once: true
+        });
+        if (signal?.aborted) return void handleAbort();
+        const transferableJob = transferablePdfPageJob(job);
+        const request = {
+            job: transferableJob.job,
+            kind: 'run'
+        };
+        try {
+            worker.postMessage(request, {
+                transfer: transferableJob.transfer
+            });
+        } catch  {
+            handleWorkerError();
+        }
+    });
+}
+async function runDirectly(job, signal) {
+    if (signal?.aborted) throw pdfPageOrganizationAbortError();
+    const { applyPdfPageOrganizationJob } = await import("./0~pdf-page-organization-engine.js");
+    if (signal?.aborted) throw pdfPageOrganizationAbortError();
+    const result = await applyPdfPageOrganizationJob(job);
+    if (signal?.aborted) throw pdfPageOrganizationAbortError();
+    return result;
+}
+function transferablePdfPageJob(job) {
+    const source = transferableSource(job.source);
+    if ('export' === job.kind) return {
+        job: {
+            ...job,
+            source: source.source
+        },
+        transfer: [
+            source.source
+        ]
+    };
+    const imported = job.importSource ? transferableSource(job.importSource) : void 0;
+    return {
+        job: {
+            ...job,
+            ...imported ? {
+                importSource: imported.source
+            } : {},
+            source: source.source
+        },
+        transfer: imported ? [
+            source.source,
+            imported.source
+        ] : [
+            source.source
+        ]
+    };
+}
+function transferableSource(source) {
+    if (source instanceof ArrayBuffer) return {
+        source
+    };
+    const copy = new Uint8Array(source.byteLength);
+    copy.set(source);
+    return {
+        source: copy.buffer
+    };
+}
+function pdfPageOrganizationAbortError() {
+    if ("u" > typeof DOMException) return new DOMException('PDF page organization was cancelled.', 'AbortError');
+    const error = new Error('PDF page organization was cancelled.');
+    error.name = 'AbortError';
+    return error;
+}
+const initialState = {
+    available: false,
+    busy: false,
+    canRedo: false,
+    canUndo: false,
+    diagnostics: [],
+    error: null,
+    revision: 0
+};
+function usePdfPageOrganization(options, runJob = runPdfPageOrganizationJob) {
+    const [state, setState] = useState({
+        ...initialState,
+        available: options.enabled
+    });
+    const undoRef = useRef([]);
+    const redoRef = useRef([]);
+    const abortRef = useRef(null);
+    const optionsRef = useRef(options);
+    const runJobRef = useRef(runJob);
+    optionsRef.current = options;
+    runJobRef.current = runJob;
+    useEffect(()=>{
+        abortRef.current?.abort();
+        abortRef.current = null;
+        undoRef.current = [];
+        redoRef.current = [];
+        setState({
+            ...initialState,
+            available: options.enabled
+        });
+    }, [
+        options.enabled,
+        options.resetKey
+    ]);
+    useEffect(()=>()=>{
+            abortRef.current?.abort();
+        }, []);
+    const mutate = useCallback(async (mutation, importSource)=>{
+        const currentOptions = optionsRef.current;
+        if (!currentOptions.enabled || abortRef.current) return false;
+        const abort = new AbortController();
+        abortRef.current = abort;
+        setState((current)=>({
+                ...current,
+                busy: true,
+                diagnostics: [],
+                error: null
+            }));
+        try {
+            const before = await currentOptions.readCurrentSource();
+            const job = {
+                ...importSource ? {
+                    importSource: await importSource.arrayBuffer()
+                } : {},
+                kind: 'mutate',
+                mutation,
+                source: await before.arrayBuffer()
+            };
+            const result = await runJobRef.current(job, abort.signal);
+            if ('mutated' !== result.kind) throw new Error('PDF page mutation returned export files.');
+            const after = pdfBlob(result.source);
+            const entry = {
+                after,
+                before
+            };
+            undoRef.current = [
+                ...undoRef.current,
+                entry
+            ];
+            redoRef.current = [];
+            currentOptions.replaceSource(after);
+            setState((current)=>({
+                    ...current,
+                    busy: false,
+                    canRedo: false,
+                    canUndo: true,
+                    diagnostics: result.diagnostics,
+                    error: null,
+                    revision: current.revision + 1
+                }));
+            return true;
+        } catch (error) {
+            if (abort.signal.aborted) return false;
+            setState((current)=>({
+                    ...current,
+                    busy: false,
+                    diagnostics: [],
+                    error: controllerError(error)
+                }));
+            return false;
+        } finally{
+            if (abortRef.current === abort) abortRef.current = null;
+        }
+    }, []);
+    const exportPages = useCallback(async (operation)=>{
+        const currentOptions = optionsRef.current;
+        if (!currentOptions.enabled || abortRef.current) return false;
+        const abort = new AbortController();
+        abortRef.current = abort;
+        setState((current)=>({
+                ...current,
+                busy: true,
+                diagnostics: [],
+                error: null
+            }));
+        try {
+            const before = await currentOptions.readCurrentSource();
+            const result = await runJobRef.current({
+                kind: 'export',
+                operation,
+                source: await before.arrayBuffer()
+            }, abort.signal);
+            if ('exported' !== result.kind) throw new Error('PDF page export returned a mutated source.');
+            const files = namedPdfExports(currentOptions.fileName, operation.kind, result);
+            const accepted = currentOptions.onExport ? await currentOptions.onExport(files) : downloadPdfExports(files);
+            if (!accepted) throw new Error('The host rejected the PDF page export.');
+            setState((current)=>({
+                    ...current,
+                    busy: false,
+                    diagnostics: result.diagnostics,
+                    error: null
+                }));
+            return true;
+        } catch (error) {
+            if (abort.signal.aborted) return false;
+            setState((current)=>({
+                    ...current,
+                    busy: false,
+                    diagnostics: [],
+                    error: controllerError(error)
+                }));
+            return false;
+        } finally{
+            if (abortRef.current === abort) abortRef.current = null;
+        }
+    }, []);
+    const undo = useCallback(()=>{
+        if (!optionsRef.current.enabled || abortRef.current) return;
+        const entry = undoRef.current.at(-1);
+        if (!entry) return;
+        undoRef.current = undoRef.current.slice(0, -1);
+        redoRef.current = [
+            ...redoRef.current,
+            entry
+        ];
+        optionsRef.current.replaceSource(entry.before);
+        setState((current)=>({
+                ...current,
+                canRedo: true,
+                canUndo: undoRef.current.length > 0,
+                diagnostics: [],
+                error: null,
+                revision: current.revision + 1
+            }));
+    }, []);
+    const redo = useCallback(()=>{
+        if (!optionsRef.current.enabled || abortRef.current) return;
+        const entry = redoRef.current.at(-1);
+        if (!entry) return;
+        redoRef.current = redoRef.current.slice(0, -1);
+        undoRef.current = [
+            ...undoRef.current,
+            entry
+        ];
+        optionsRef.current.replaceSource(entry.after);
+        setState((current)=>({
+                ...current,
+                canRedo: redoRef.current.length > 0,
+                canUndo: true,
+                diagnostics: [],
+                error: null,
+                revision: current.revision + 1
+            }));
+    }, []);
+    const dismissError = useCallback(()=>{
+        setState((current)=>({
+                ...current,
+                error: null
+            }));
+    }, []);
+    return useMemo(()=>({
+            state,
+            dismissError,
+            exportPages,
+            mutate,
+            redo,
+            undo
+        }), [
+        dismissError,
+        exportPages,
+        mutate,
+        redo,
+        state,
+        undo
+    ]);
+}
+function namedPdfExports(fileName, kind, result) {
+    const stem = fileName.replace(/\.pdf$/i, '') || 'document';
+    return result.files.map((file, index)=>({
+            fileName: 'extract' === kind ? `${stem}-extracted.pdf` : `${stem}-part-${index + 1}.pdf`,
+            pageCount: file.pageCount,
+            pdf: pdfBlob(file.source)
+        }));
+}
+function pdfBlob(source) {
+    const copy = new Uint8Array(source.byteLength);
+    copy.set(source);
+    return new Blob([
+        copy.buffer
+    ], {
+        type: 'application/pdf'
+    });
+}
+function downloadPdfExports(files) {
+    if ("u" < typeof document || 'function' != typeof URL.createObjectURL) return false;
+    for (const file of files){
+        const url = URL.createObjectURL(file.pdf);
+        const anchor = document.createElement('a');
+        anchor.href = url;
+        anchor.download = file.fileName;
+        anchor.hidden = true;
+        document.body.append(anchor);
+        anchor.click();
+        anchor.remove();
+        queueMicrotask(()=>URL.revokeObjectURL(url));
+    }
+    return true;
+}
+function controllerError(error) {
+    const candidate = error;
+    return {
+        code: 'string' == typeof candidate?.code && candidate.code.startsWith('pdf.pages.') ? candidate.code : 'pdf.pages.invalid-source',
+        message: 'string' == typeof candidate?.message && candidate.message ? candidate.message.slice(0, 512) : 'Unable to organize this PDF.'
+    };
+}
 const PDFIUM_WASM_PATH = '/vendor/embedpdf/pdfium.wasm';
 const PDF_VIEWER_READY_TIMEOUT_MS = 45000;
 const PDF_MOBILE_PAGE_NAVIGATION_QUERY = '(max-width: 640px)';
@@ -2753,13 +3664,16 @@ const a3sPdfUiSchema = {
     overlays: {},
     selectionMenus: {}
 };
-function PdfViewer({ collaboration, evidenceOverlay, fileName = 'document.pdf', loadSource, onCollaborationChange, onEvidenceRegionSelect, onPageChange, onSave, saveLabel = '保存', selectedEvidenceRegionId, sourceKey, wasmUrl, worker = true }) {
+function PdfViewer({ collaboration, evidenceOverlay, fileName = 'document.pdf', loadSource, onCollaborationChange, onEvidenceRegionSelect, onPageChange, onPageExport, onSave, saveLabel = '保存', selectedEvidenceRegionId, sourceKey, wasmUrl, worker = true }) {
+    const [sourceBlob, setSourceBlob] = useState(null);
     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 [, refreshCollaborationHistory] = useState(0);
+    const [hostSourceGeneration, setHostSourceGeneration] = useState(0);
+    const [pageOrganizerOpen, setPageOrganizerOpen] = useState(false);
     const [mobilePageNavigationOpen, setMobilePageNavigationOpen] = useState(false);
     const pdfRootRef = useRef(null);
     const searchInputRef = useRef(null);
@@ -2767,6 +3681,8 @@ function PdfViewer({ collaboration, evidenceOverlay, fileName = 'document.pdf',
     const mobilePageNavigationToggleRef = useRef(null);
     const mobilePageNavigationCloseRef = useRef(null);
     const collaborationProjectionRef = useRef(void 0);
+    const editable = collaboration ? 'edit' === collaboration.mode : Boolean(onSave);
+    const pageOrganizationEnabled = Boolean(onSave) && !collaboration && !evidenceOverlay;
     const collaborationHistory = collaboration ? {
         canRedo: collaborationProjectionRef.current?.binding.canRedo() ?? false,
         canUndo: collaborationProjectionRef.current?.binding.canUndo() ?? false,
@@ -2774,11 +3690,54 @@ function PdfViewer({ collaboration, evidenceOverlay, fileName = 'document.pdf',
         undo: ()=>collaborationProjectionRef.current?.binding.undo()
     } : void 0;
     const controller = usePdfViewerController(registry, collaborationHistory);
+    const replacePageSource = useCallback((source)=>{
+        setRegistry(null);
+        setSourceUrl(null);
+        setSourceBlob('application/pdf' === source.type ? source : new Blob([
+            source
+        ], {
+            type: 'application/pdf'
+        }));
+        setLoadError(null);
+        setSaveState('idle');
+        setMobilePageNavigationOpen(false);
+        setPageOrganizerOpen(false);
+    }, []);
+    const pageOrganization = usePdfPageOrganization({
+        enabled: pageOrganizationEnabled,
+        fileName,
+        onExport: onPageExport,
+        readCurrentSource: ()=>controller.saveAsCopy(),
+        replaceSource: replacePageSource,
+        resetKey: `${sourceKey ?? 'source'}:${retryCount}:${hostSourceGeneration}`
+    });
+    const viewerController = useMemo(()=>({
+            ...controller,
+            state: {
+                ...controller.state,
+                canRedo: controller.state.canRedo || pageOrganization.state.canRedo,
+                canUndo: controller.state.canUndo || pageOrganization.state.canUndo,
+                features: {
+                    ...controller.state.features,
+                    history: controller.state.features.history || pageOrganization.state.available
+                }
+            },
+            redo: ()=>{
+                if (controller.state.canRedo) controller.redo();
+                else pageOrganization.redo();
+            },
+            undo: ()=>{
+                if (controller.state.canUndo) controller.undo();
+                else pageOrganization.undo();
+            }
+        }), [
+        controller,
+        pageOrganization
+    ]);
     const annotation = usePdfAnnotationController(registry);
-    const viewerReady = controller.state.ready && controller.state.documentOpen;
+    const viewerReady = viewerController.state.ready && viewerController.state.documentOpen;
     const mobilePageNavigationModal = usePdfMobilePageNavigationModal();
     const mobilePageNavigationModalOpen = mobilePageNavigationOpen && mobilePageNavigationModal;
-    const editable = collaboration ? 'edit' === collaboration.mode : Boolean(onSave);
     const collaborationRef = useRef(collaboration);
     if (collaborationRef.current !== collaboration) throw new Error('PdfViewer collaboration sessions cannot be replaced while mounted. Remount the viewer for another shared PDF.');
     const closeMobilePageNavigation = useCallback(()=>{
@@ -2796,28 +3755,28 @@ function PdfViewer({ collaboration, evidenceOverlay, fileName = 'document.pdf',
     });
     useEffect(()=>{
         let disposed = false;
-        let objectUrl = null;
         setRegistry(null);
         setSaveState('idle');
+        setSourceBlob(null);
         setSourceUrl(null);
         setLoadError(null);
         setMobilePageNavigationOpen(false);
+        setPageOrganizerOpen(false);
         loadSource().then(async (source)=>{
             if (disposed) return;
             if (collaboration) await assertPdfCollaborationBlob(collaboration, source);
             if (disposed) return;
-            objectUrl = URL.createObjectURL('application/pdf' === source.type ? source : new Blob([
+            setSourceBlob('application/pdf' === source.type ? source : new Blob([
                 source
             ], {
                 type: 'application/pdf'
             }));
-            setSourceUrl(objectUrl);
+            setHostSourceGeneration((value)=>value + 1);
         }).catch((error)=>{
             if (!disposed) setLoadError(pdfErrorMessage(error));
         });
         return ()=>{
             disposed = true;
-            if (objectUrl) URL.revokeObjectURL(objectUrl);
         };
     }, [
         collaboration,
@@ -2825,6 +3784,14 @@ function PdfViewer({ collaboration, evidenceOverlay, fileName = 'document.pdf',
         retryCount,
         sourceKey
     ]);
+    useEffect(()=>{
+        if (!sourceBlob) return void setSourceUrl(null);
+        const objectUrl = URL.createObjectURL(sourceBlob);
+        setSourceUrl(objectUrl);
+        return ()=>URL.revokeObjectURL(objectUrl);
+    }, [
+        sourceBlob
+    ]);
     useEffect(()=>{
         if (controller.state.error) setLoadError(controller.state.error);
     }, [
@@ -2888,10 +3855,10 @@ function PdfViewer({ collaboration, evidenceOverlay, fileName = 'document.pdf',
         onCollaborationChange
     ]);
     useEffect(()=>{
-        if (controller.state.currentPage > 0) onPageChange?.(controller.state.currentPage);
+        if (viewerController.state.currentPage > 0) onPageChange?.(viewerController.state.currentPage);
     }, [
-        controller.state.currentPage,
-        onPageChange
+        onPageChange,
+        viewerController.state.currentPage
     ]);
     useEffect(()=>{
         if (!sourceUrl || viewerReady || loadError) return;
@@ -2927,17 +3894,19 @@ function PdfViewer({ collaboration, evidenceOverlay, fileName = 'document.pdf',
             searchInputRef.current?.focus();
             searchInputRef.current?.select();
         },
+        openPageOrganizer: ()=>setPageOrganizerOpen(true),
+        pages: pageOrganization,
         save: {
             enabled: Boolean(onSave) && 'saving' !== saveState,
             execute: savePdf
         },
-        viewer: controller
+        viewer: viewerController
     }, pdfExtensions);
     const pdfCommands = pdfEditor.commands;
     const selectedAnnotationLocation = annotation.getSelectionLocation();
-    const pdfPresenceLocation = viewerReady && controller.state.currentPage > 0 ? {
+    const pdfPresenceLocation = viewerReady && viewerController.state.currentPage > 0 ? {
         kind: 'pdf',
-        pageIndex: selectedAnnotationLocation?.pageIndex ?? controller.state.currentPage - 1,
+        pageIndex: selectedAnnotationLocation?.pageIndex ?? viewerController.state.currentPage - 1,
         ...selectedAnnotationLocation ? {
             annotationId: selectedAnnotationLocation.annotationId
         } : {}
@@ -2945,8 +3914,8 @@ function PdfViewer({ collaboration, evidenceOverlay, fileName = 'document.pdf',
     useOfficePublishPresenceLocation(pdfPresenceLocation);
     const navigateToPdfParticipant = useCallback((participant)=>{
         const location = participant.location;
-        if (location?.kind !== 'pdf' || !viewerReady || location.pageIndex >= controller.state.totalPages) return false;
-        controller.goToPage(location.pageIndex + 1);
+        if (location?.kind !== 'pdf' || !viewerReady || location.pageIndex >= viewerController.state.totalPages) return false;
+        viewerController.goToPage(location.pageIndex + 1);
         if (location.annotationId) annotation.locateAnnotation(location.pageIndex, location.annotationId);
         requestAnimationFrame(()=>{
             const target = pdfRootRef.current?.querySelector('.work-pdf-embed');
@@ -2957,7 +3926,7 @@ function PdfViewer({ collaboration, evidenceOverlay, fileName = 'document.pdf',
         return true;
     }, [
         annotation,
-        controller,
+        viewerController,
         viewerReady
     ]);
     useOfficeCollaborationLocationNavigator(navigateToPdfParticipant);
@@ -3006,8 +3975,9 @@ function PdfViewer({ collaboration, evidenceOverlay, fileName = 'document.pdf',
                 can: pdfEditor.can(),
                 commands: pdfCommands,
                 editable: editable,
+                pageOrganizationAvailable: pageOrganization.state.available,
                 saveAvailable: editable && Boolean(onSave),
-                pageNavigation: viewerReady && registry && controller.state.totalPages > 0 ? {
+                pageNavigation: viewerReady && registry && viewerController.state.totalPages > 0 ? {
                     controlsId: mobilePageNavigationId,
                     expanded: mobilePageNavigationOpen,
                     onOpen: ()=>setMobilePageNavigationOpen(true),
@@ -3016,22 +3986,35 @@ function PdfViewer({ collaboration, evidenceOverlay, fileName = 'document.pdf',
                 searchInputRef: searchInputRef,
                 saveLabel: saveLabel,
                 saveState: saveState,
-                state: controller.state
+                state: viewerController.state
+            }),
+            pageOrganizerOpen && viewerReady && registry && viewerController.state.totalPages > 0 && /*#__PURE__*/ jsx(PdfPageOrganizerDialog, {
+                busy: pageOrganization.state.busy,
+                can: pdfEditor.can(),
+                commands: pdfCommands,
+                currentPage: viewerController.state.currentPage,
+                diagnostics: pageOrganization.state.diagnostics,
+                error: pageOrganization.state.error,
+                registry: registry,
+                restoreFocusTarget: ()=>pdfPageOrganizerRestoreFocusTarget(pdfRootRef.current),
+                totalPages: viewerController.state.totalPages,
+                onClose: ()=>setPageOrganizerOpen(false),
+                onDismissError: pageOrganization.dismissError
             }),
             /*#__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,
+                    viewerReady && registry && viewerController.state.totalPages > 0 && /*#__PURE__*/ jsx(PdfThumbnailRail, {
+                        currentPage: viewerController.state.currentPage,
                         mobileCloseButtonRef: mobilePageNavigationCloseRef,
                         mobileNavigationId: mobilePageNavigationId,
                         mobileNavigationModal: mobilePageNavigationModalOpen,
                         registry: registry,
-                        totalPages: controller.state.totalPages,
+                        totalPages: viewerController.state.totalPages,
                         onCloseMobileNavigation: closeMobilePageNavigation,
                         onSelectPage: (page)=>{
-                            controller.goToPage(page);
+                            viewerController.goToPage(page);
                             if (mobilePageNavigationModalOpen) closeMobilePageNavigation();
                         }
                     }),
@@ -3109,11 +4092,11 @@ function PdfViewer({ collaboration, evidenceOverlay, fileName = 'document.pdf',
                                 },
                                 onReady: setRegistry
                             }, sourceUrl),
-                            viewerReady && controller.state.currentPage > 0 && /*#__PURE__*/ jsx(PdfCollaborationPresenceLayer, {
-                                pageIndex: controller.state.currentPage - 1
+                            viewerReady && viewerController.state.currentPage > 0 && /*#__PURE__*/ jsx(PdfCollaborationPresenceLayer, {
+                                pageIndex: viewerController.state.currentPage - 1
                             }),
                             evidenceOverlay && registry && viewerReady && /*#__PURE__*/ jsx(PdfEvidenceOverlayLayer, {
-                                currentPage: controller.state.currentPage,
+                                currentPage: viewerController.state.currentPage,
                                 evidenceOverlay: evidenceOverlay,
                                 onEvidenceRegionSelect: onEvidenceRegionSelect,
                                 registry: registry,
@@ -3142,6 +4125,11 @@ function pdfErrorMessage(error) {
     if (error instanceof Error && error.message) return error.message;
     return 'Unable to read this PDF file.';
 }
+function pdfPageOrganizerRestoreFocusTarget(root) {
+    const directTrigger = root?.querySelector('[data-pdf-page-organizer-trigger]');
+    if (directTrigger && directTrigger.getClientRects().length > 0) return directTrigger;
+    return root?.querySelector('.work-pdf-overflow-trigger') ?? null;
+}
 async function assertPdfCollaborationBlob(session, source) {
     const expected = readWorkOfficePdfCollaborationSource(session);
     if (source.size !== expected.byteLength) throw new Error(`The loaded PDF source does not match collaboration artifact '${session.artifactId}'.`);
@@ -3176,4 +4164,4 @@ function pdfMediaQueryMatches(query) {
     if ("u" < typeof window || 'function' != typeof window.matchMedia) return true;
     return window.matchMedia(query).matches;
 }
-export { pdf_viewer_namespaceObject };
+export { PDF_PAGE_ORGANIZATION_MAX_IMPORT_BYTES, PDF_PAGE_ORGANIZATION_MAX_SOURCE_BYTES, PdfPageOrganizationError, pdf_viewer_namespaceObject, validatedPdfInsertionIndex, validatedPdfPageIndexes, validatedPdfPageOrder, validatedPdfPageSize, validatedPdfSplitBoundaries };