@a3s-lab/office 0.1.0

package/dist/0~work-document-extensions.js

@@ -0,0 +1,2470 @@
+import extension_color from "@tiptap/extension-color";
+import extension_highlight from "@tiptap/extension-highlight";
+import { TableKit, createTable } from "@tiptap/extension-table";
+import extension_text_align from "@tiptap/extension-text-align";
+import { TextStyle } from "@tiptap/extension-text-style";
+import font_family from "@tiptap/extension-text-style/font-family";
+import font_size from "@tiptap/extension-text-style/font-size";
+import extension_underline from "@tiptap/extension-underline";
+import starter_kit from "@tiptap/starter-kit";
+import { Extension, Mark, Node, mergeAttributes } from "@tiptap/core";
+import { NodeSelection, Plugin, PluginKey, TextSelection } from "@tiptap/pm/state";
+import { DOMParser as model_DOMParser, Fragment, Slice } from "@tiptap/pm/model";
+import extension_subscript from "@tiptap/extension-subscript";
+import extension_superscript from "@tiptap/extension-superscript";
+import { Decoration, DecorationSet } from "@tiptap/pm/view";
+import { BulletList, OrderedList } from "@tiptap/extension-list";
+import { documentFieldLabel, documentSections, documentCaptionLabel, documentCaptionKind, renameDocumentCitationTagInInstruction, documentNoteReferenceKeys, collectDocumentNotes, documentSectionNodeAttributes, syncDocumentContentFromHtml, documentFieldInstruction, documentCitationTagsFromInstruction, documentCitationInstruction, documentCitationTags, documentFieldKind, documentSectionDomAttributes, documentFieldDisplay, docxDocumentFieldKind, renderDocumentBibliographyHtml, documentSectionLayoutFromNodeAttributes, documentNoteKey, documentCaptionDisplay, resolveDocumentCitation, removeDocumentNoteDefinitions, resolveDocumentFieldsHtml, documentNoteKind } from "./4704.js";
+import { createOfficeId as createWorkId } from "./1134.js";
+import { DocumentParagraphTabStops, DocumentImage, normalizeDocumentTabStops } from "./0~8155.js";
+import { DocumentTable, DocumentTableCell, DocumentTableHeader, DocumentTableRow, DocumentTableSizing, DocumentTableFormatting } from "./0~6552.js";
+import { DocumentParagraphFormatting } from "./0~work-document-paragraph-formatting.js";
+function activeDocumentSection(editor) {
+    return activeDocumentSectionFromState(editor.state);
+}
+function activeDocumentSectionFromState(state) {
+    const { doc, selection } = state;
+    let position = null;
+    let node = null;
+    for(let depth = selection.$from.depth; depth > 0; depth -= 1){
+        const candidate = selection.$from.node(depth);
+        if ('documentSection' === candidate.type.name) {
+            position = selection.$from.before(depth);
+            node = candidate;
+            break;
+        }
+    }
+    const sections = directDocumentSections(doc);
+    if (!node || null === position) {
+        const containing = sections.find((section)=>selection.from >= section.position && selection.from <= section.position + section.node.nodeSize);
+        if (!containing) return null;
+        position = containing.position;
+        node = containing.node;
+    }
+    const index = sections.findIndex((section)=>section.position === position);
+    if (index < 0) return null;
+    const id = 'string' == typeof node.attrs.id && node.attrs.id ? node.attrs.id : `document-section-${index + 1}`;
+    return {
+        id,
+        index,
+        count: sections.length,
+        position,
+        node,
+        layout: documentSectionLayoutFromNodeAttributes(node.attrs)
+    };
+}
+function updateActiveDocumentSection(layout, commandContext) {
+    const state = commandContext.state;
+    const section = activeDocumentSectionFromState(state);
+    if (!section) return false;
+    return updateDocumentSection(section.id, layout, commandContext);
+}
+function documentSectionById(editor, sectionId) {
+    return documentSectionByIdInDocument(editor.state.doc, sectionId);
+}
+function updateDocumentSection(sectionId, layout, commandContext) {
+    const state = commandContext.state;
+    const section = documentSectionByIdInDocument(state.doc, sectionId);
+    if (!section) return false;
+    commandContext.tr.setNodeMarkup(section.position, void 0, documentSectionNodeAttributes(layout, section.id));
+    return true;
+}
+function insertDocumentSection(editor, breakAfter, commandContext) {
+    const state = commandContext.state;
+    const section = activeDocumentSectionFromState(state);
+    const sectionType = editor.schema.nodes.documentSection;
+    const paragraphType = editor.schema.nodes.paragraph;
+    if (!section || !sectionType || !paragraphType) return false;
+    const children = [];
+    section.node.forEach((child)=>{
+        children.push(child);
+    });
+    const activeChildIndex = sectionChildIndex(section, state.selection.from);
+    const currentChildren = children.slice(0, activeChildIndex + 1);
+    const followingChildren = children.slice(activeChildIndex + 1);
+    if (!currentChildren.length) currentChildren.push(paragraphType.create());
+    if (!followingChildren.length) followingChildren.push(paragraphType.create());
+    const currentLayout = {
+        ...section.layout,
+        breakAfter
+    };
+    const nextLayout = {
+        ...section.layout,
+        margins: {
+            ...section.layout.margins
+        },
+        columns: {
+            ...section.layout.columns
+        },
+        breakAfter: 'nextPage',
+        pageNumberStart: void 0
+    };
+    const currentNode = sectionType.create(documentSectionNodeAttributes(currentLayout, section.id), Fragment.fromArray(currentChildren));
+    const nextNode = sectionType.create(documentSectionNodeAttributes(nextLayout, createWorkId('section')), Fragment.fromArray(followingChildren));
+    const transaction = commandContext.tr.replaceWith(section.position, section.position + section.node.nodeSize, Fragment.fromArray([
+        currentNode,
+        nextNode
+    ]));
+    const nextPosition = section.position + currentNode.nodeSize + 1;
+    transaction.setSelection(TextSelection.near(transaction.doc.resolve(nextPosition)));
+    transaction.scrollIntoView();
+    return true;
+}
+function mergeDocumentSectionWithPrevious(_editor, commandContext) {
+    const state = commandContext.state;
+    const section = activeDocumentSectionFromState(state);
+    if (!section || 0 === section.index) return false;
+    const sections = directDocumentSections(state.doc);
+    const previous = sections[section.index - 1];
+    const merged = previous.node.type.create(previous.node.attrs, previous.node.content.append(section.node.content), previous.node.marks);
+    const transaction = commandContext.tr.replaceWith(previous.position, section.position + section.node.nodeSize, merged);
+    const selectionPosition = Math.min(previous.position + previous.node.nodeSize - 1, transaction.doc.content.size);
+    transaction.setSelection(TextSelection.near(transaction.doc.resolve(selectionPosition)));
+    transaction.scrollIntoView();
+    return true;
+}
+function documentSectionByIdInDocument(document1, sectionId) {
+    const sections = directDocumentSections(document1);
+    const index = sections.findIndex(({ node }, candidateIndex)=>{
+        const id = 'string' == typeof node.attrs.id && node.attrs.id ? node.attrs.id : `document-section-${candidateIndex + 1}`;
+        return id === sectionId;
+    });
+    const section = sections[index];
+    if (!section) return null;
+    return {
+        id: sectionId,
+        index,
+        count: sections.length,
+        position: section.position,
+        node: section.node,
+        layout: documentSectionLayoutFromNodeAttributes(section.node.attrs)
+    };
+}
+function directDocumentSections(document1) {
+    const sections = [];
+    document1.forEach((node, position)=>{
+        if ('documentSection' === node.type.name) sections.push({
+            position,
+            node
+        });
+    });
+    return sections;
+}
+function sectionChildIndex(section, selectionPosition) {
+    const relativePosition = Math.max(0, selectionPosition - section.position - 1);
+    let activeIndex = 0;
+    section.node.forEach((_child, offset, index)=>{
+        if (relativePosition >= offset) activeIndex = index;
+    });
+    return activeIndex;
+}
+const DocumentCaption = Node.create({
+    name: 'documentCaption',
+    priority: 110,
+    group: 'block',
+    content: 'inline*',
+    defining: true,
+    addCommands () {
+        return {
+            insertDocumentCaption: (kind, title)=>(props)=>insertDocumentCaptionCommand(props, kind, title),
+            insertDocumentCrossReference: (target)=>(props)=>insertDocumentCrossReferenceCommand(props, target)
+        };
+    },
+    addKeyboardShortcuts () {
+        return {
+            Backspace: ()=>deleteEmptyDocumentCaption(this.editor)
+        };
+    },
+    addProseMirrorPlugins () {
+        return [
+            new Plugin({
+                appendTransaction (transactions, _oldState, newState) {
+                    if (!transactions.some((transaction)=>transaction.docChanged)) return null;
+                    return synchronizeDocumentCaptionState(newState);
+                }
+            })
+        ];
+    },
+    addAttributes () {
+        return {
+            id: hiddenAttribute(''),
+            kind: hiddenAttribute('figure'),
+            number: hiddenAttribute(1),
+            accessibleName: hiddenAttribute('')
+        };
+    },
+    parseHTML () {
+        return [
+            {
+                tag: 'figcaption[data-document-caption]',
+                getAttrs: (node)=>{
+                    if (!(node instanceof HTMLElement)) return false;
+                    return {
+                        id: node.dataset.captionId ?? '',
+                        kind: documentCaptionKind(node.dataset.captionKind) ?? 'figure',
+                        number: positiveInteger(node.dataset.captionNumber),
+                        accessibleName: node.getAttribute('aria-label') ?? ''
+                    };
+                }
+            }
+        ];
+    },
+    renderHTML ({ node, HTMLAttributes }) {
+        const kind = documentCaptionKind(node.attrs.kind) ?? 'figure';
+        const number = positiveInteger(node.attrs.number);
+        const accessibleName = documentCaptionAccessibleName(kind, number, node.textContent);
+        return [
+            'figcaption',
+            mergeAttributes(HTMLAttributes, {
+                'data-document-caption': 'true',
+                'data-caption-id': 'string' == typeof node.attrs.id ? node.attrs.id : '',
+                'data-caption-kind': kind,
+                'data-caption-number': String(number),
+                'data-caption-label': documentCaptionLabel(kind),
+                'aria-label': accessibleName,
+                class: 'work-document-caption'
+            }),
+            0
+        ];
+    },
+    renderText ({ node }) {
+        const kind = documentCaptionKind(node.attrs.kind) ?? 'figure';
+        return `${documentCaptionDisplay(kind, positiveInteger(node.attrs.number))} ${node.textContent}`.trim();
+    }
+});
+const DocumentCrossReference = Node.create({
+    name: 'documentCrossReference',
+    inline: true,
+    group: 'inline',
+    atom: true,
+    selectable: true,
+    addAttributes () {
+        return {
+            targetId: hiddenAttribute(''),
+            kind: hiddenAttribute('figure'),
+            number: hiddenAttribute(1),
+            orphaned: hiddenAttribute(false)
+        };
+    },
+    parseHTML () {
+        return [
+            {
+                tag: 'span[data-document-cross-reference]',
+                getAttrs: (node)=>{
+                    if (!(node instanceof HTMLElement)) return false;
+                    return {
+                        targetId: node.dataset.referenceTargetId ?? '',
+                        kind: documentCaptionKind(node.dataset.captionKind) ?? 'figure',
+                        number: positiveInteger(node.dataset.captionNumber),
+                        orphaned: 'true' === node.dataset.referenceOrphaned
+                    };
+                }
+            }
+        ];
+    },
+    renderHTML ({ node, HTMLAttributes }) {
+        const kind = documentCaptionKind(node.attrs.kind) ?? 'figure';
+        const number = positiveInteger(node.attrs.number);
+        const orphaned = Boolean(node.attrs.orphaned);
+        return [
+            'span',
+            mergeAttributes(HTMLAttributes, {
+                'data-document-cross-reference': 'true',
+                'data-reference-target-id': 'string' == typeof node.attrs.targetId ? node.attrs.targetId : '',
+                'data-caption-kind': kind,
+                'data-caption-number': String(number),
+                'data-caption-label': documentCaptionLabel(kind),
+                'data-reference-orphaned': orphaned ? 'true' : void 0,
+                class: 'work-document-cross-reference'
+            }),
+            orphaned ? '引用缺失' : documentCaptionDisplay(kind, number)
+        ];
+    },
+    renderText ({ node }) {
+        if (node.attrs.orphaned) return '引用缺失';
+        const kind = documentCaptionKind(node.attrs.kind) ?? 'figure';
+        return documentCaptionDisplay(kind, positiveInteger(node.attrs.number));
+    }
+});
+function editorDocumentCaptionTargets(editor) {
+    return documentCaptionTargets(editor.state.doc);
+}
+function insertDocumentCaptionCommand({ dispatch, editor, state, tr }, kind, title) {
+    const section = activeDocumentSectionFromState(state);
+    const captionType = editor.schema.nodes.documentCaption;
+    const paragraphType = editor.schema.nodes.paragraph;
+    if (!section || !captionType || !paragraphType || selectionInsideNode(state, 'documentCaption')) return false;
+    const child = activeSectionChild(section, state.selection.from);
+    if (!child) return false;
+    if (!dispatch) return true;
+    const id = createWorkId(`caption-${kind}`);
+    const number = nextCaptionNumber(state.doc, kind);
+    const normalizedTitle = title.trim();
+    const caption = captionType.create({
+        id,
+        kind,
+        number,
+        accessibleName: documentCaptionAccessibleName(kind, number, normalizedTitle)
+    }, normalizedTitle ? editor.schema.text(normalizedTitle) : void 0);
+    const insertPosition = section.position + 1 + child.offset + child.nodeSize;
+    tr.insert(insertPosition, caption);
+    let selectionPosition = insertPosition + caption.nodeSize;
+    if (child.index === section.node.childCount - 1) {
+        tr.insert(selectionPosition, paragraphType.create());
+        selectionPosition += 1;
+    }
+    tr.setSelection(TextSelection.near(tr.doc.resolve(selectionPosition)));
+    tr.scrollIntoView();
+    return true;
+}
+function insertDocumentCrossReferenceCommand({ dispatch, editor, tr }, target) {
+    const referenceType = editor.schema.nodes.documentCrossReference;
+    if (!referenceType || !target.id.trim()) return false;
+    if (!dispatch) return true;
+    tr.replaceSelectionWith(referenceType.create({
+        targetId: target.id,
+        kind: target.kind,
+        number: target.number,
+        orphaned: false
+    }), false);
+    tr.scrollIntoView();
+    return true;
+}
+function synchronizeDocumentCaptionState(state) {
+    const counters = {
+        figure: 0,
+        table: 0
+    };
+    const targets = new Map();
+    const transaction = state.tr;
+    let changed = false;
+    state.doc.descendants((node, position)=>{
+        if ('documentCaption' !== node.type.name) return;
+        const kind = documentCaptionKind(node.attrs.kind) ?? 'figure';
+        counters[kind] += 1;
+        const number = counters[kind];
+        const accessibleName = documentCaptionAccessibleName(kind, number, node.textContent);
+        const id = 'string' == typeof node.attrs.id ? node.attrs.id.trim() : '';
+        if (id && !targets.has(id)) targets.set(id, {
+            kind,
+            number
+        });
+        if (node.attrs.kind === kind && node.attrs.number === number && node.attrs.accessibleName === accessibleName) return;
+        transaction.setNodeMarkup(position, void 0, {
+            ...node.attrs,
+            kind,
+            number,
+            accessibleName
+        });
+        changed = true;
+    });
+    state.doc.descendants((node, position)=>{
+        if ('documentCrossReference' !== node.type.name) return;
+        const targetId = 'string' == typeof node.attrs.targetId ? node.attrs.targetId.trim() : '';
+        const target = targets.get(targetId);
+        const kind = target?.kind ?? documentCaptionKind(node.attrs.kind) ?? 'figure';
+        const number = target?.number ?? positiveInteger(node.attrs.number);
+        const orphaned = !target;
+        if (node.attrs.targetId === targetId && node.attrs.kind === kind && node.attrs.number === number && node.attrs.orphaned === orphaned) return;
+        transaction.setNodeMarkup(position, void 0, {
+            ...node.attrs,
+            targetId,
+            kind,
+            number,
+            orphaned
+        });
+        changed = true;
+    });
+    return changed ? transaction : null;
+}
+function deleteEmptyDocumentCaption(editor) {
+    const caption = emptyDocumentCaptionAtSelection(editor);
+    if (!caption) return false;
+    const transaction = editor.state.tr.delete(caption.position, caption.position + caption.nodeSize);
+    transaction.setSelection(TextSelection.near(transaction.doc.resolve(Math.min(caption.position, transaction.doc.content.size)), -1));
+    editor.view.dispatch(transaction.scrollIntoView());
+    return true;
+}
+function emptyDocumentCaptionAtSelection(editor) {
+    const { selection } = editor.state;
+    if (selection.empty) for(let depth = selection.$from.depth; depth > 0; depth -= 1){
+        const node = selection.$from.node(depth);
+        if ('documentCaption' === node.type.name) return 0 === node.content.size ? {
+            position: selection.$from.before(depth),
+            nodeSize: node.nodeSize
+        } : null;
+    }
+    const domSelection = editor.view.dom.ownerDocument.getSelection();
+    const anchor = domSelection?.anchorNode;
+    const anchorElement = anchor instanceof HTMLElement ? anchor : anchor?.parentElement;
+    const captionElement = anchorElement?.closest('figcaption[data-document-caption]');
+    const id = captionElement?.dataset.captionId?.trim();
+    if (!captionElement || !id || !editor.view.dom.contains(captionElement)) return null;
+    let match = null;
+    editor.state.doc.descendants((node, position)=>{
+        if (match || 'documentCaption' !== node.type.name || node.attrs.id !== id || node.content.size > 0) return;
+        match = {
+            position,
+            nodeSize: node.nodeSize
+        };
+    });
+    return match;
+}
+function documentCaptionAccessibleName(kind, number, title) {
+    const display = documentCaptionDisplay(kind, number);
+    const normalizedTitle = title.trim();
+    return normalizedTitle ? `${display} ${normalizedTitle}` : display;
+}
+function documentCaptionTargets(document1) {
+    const targets = [];
+    document1.descendants((node)=>{
+        if ('documentCaption' !== node.type.name) return;
+        const id = 'string' == typeof node.attrs.id ? node.attrs.id.trim() : '';
+        const kind = documentCaptionKind(node.attrs.kind);
+        if (!id || !kind) return;
+        const number = positiveInteger(node.attrs.number);
+        targets.push({
+            id,
+            kind,
+            number,
+            label: 'figure' === kind ? '图' : '表',
+            title: node.textContent.trim(),
+            display: documentCaptionDisplay(kind, number)
+        });
+    });
+    return targets;
+}
+function nextCaptionNumber(document1, kind) {
+    return documentCaptionTargets(document1).filter((caption)=>caption.kind === kind).length + 1;
+}
+function activeSectionChild(section, selectionPosition) {
+    const relativePosition = Math.max(0, selectionPosition - section.position - 1);
+    let active = null;
+    section.node.forEach((node, offset, index)=>{
+        if (relativePosition >= offset) active = {
+            index,
+            offset,
+            nodeSize: node.nodeSize
+        };
+    });
+    return active;
+}
+function selectionInsideNode(state, nodeName) {
+    for(let depth = state.selection.$from.depth; depth > 0; depth -= 1)if (state.selection.$from.node(depth).type.name === nodeName) return true;
+    return false;
+}
+function hiddenAttribute(defaultValue) {
+    return {
+        default: defaultValue,
+        rendered: false
+    };
+}
+function positiveInteger(value) {
+    const number = Number(value);
+    return Number.isSafeInteger(number) && number > 0 ? number : 1;
+}
+const DocumentSubscript = extension_subscript.extend({
+    excludes: "superscript",
+    addCommands () {
+        return {
+            ...this.parent?.() ?? {},
+            toggleDocumentSubscript: ()=>({ chain, editor })=>{
+                    const commandChain = chain().focus();
+                    return editor.isActive("subscript") ? commandChain.unsetSubscript().run() : commandChain.unsetSuperscript().setSubscript().run();
+                }
+        };
+    },
+    addKeyboardShortcuts () {
+        return {
+            'Mod-,': ()=>this.editor.commands.toggleDocumentSubscript()
+        };
+    }
+});
+const DocumentSuperscript = extension_superscript.extend({
+    excludes: "subscript",
+    addCommands () {
+        return {
+            ...this.parent?.() ?? {},
+            toggleDocumentSuperscript: ()=>({ chain, editor })=>{
+                    const commandChain = chain().focus();
+                    return editor.isActive("superscript") ? commandChain.unsetSuperscript().run() : commandChain.unsetSubscript().setSuperscript().run();
+                }
+        };
+    },
+    addKeyboardShortcuts () {
+        return {
+            'Mod-.': ()=>this.editor.commands.toggleDocumentSuperscript()
+        };
+    }
+});
+const documentChangePluginKey = new PluginKey('documentChangeTracking');
+const CONTINUOUS_INSERTION_WINDOW_MS = 30000;
+const DocumentChange = Mark.create({
+    name: 'documentChange',
+    priority: 1100,
+    inclusive: false,
+    keepOnSplit: false,
+    addOptions () {
+        return {
+            isTracking: ()=>false,
+            createChange: ()=>({
+                    id: createDocumentChangeId(),
+                    author: 'A3S Work',
+                    date: new Date().toISOString()
+                }),
+            onTrackingChange: ()=>void 0
+        };
+    },
+    addAttributes () {
+        return {
+            kind: {
+                default: 'insertion',
+                parseHTML: (element)=>'del' === element.tagName.toLowerCase() ? 'deletion' : 'insertion',
+                renderHTML: (attributes)=>({
+                        'data-change-kind': attributes.kind
+                    })
+            },
+            id: {
+                default: '',
+                parseHTML: (element)=>element.getAttribute('data-change-id') ?? '',
+                renderHTML: (attributes)=>({
+                        'data-change-id': attributes.id
+                    })
+            },
+            author: {
+                default: '',
+                parseHTML: (element)=>element.getAttribute('data-change-author') ?? '',
+                renderHTML: (attributes)=>({
+                        'data-change-author': attributes.author
+                    })
+            },
+            date: {
+                default: '',
+                parseHTML: (element)=>element.getAttribute('data-change-date') ?? '',
+                renderHTML: (attributes)=>({
+                        'data-change-date': attributes.date
+                    })
+            }
+        };
+    },
+    parseHTML () {
+        return [
+            {
+                tag: 'ins[data-document-change]'
+            },
+            {
+                tag: 'del[data-document-change]'
+            }
+        ];
+    },
+    renderHTML ({ mark, HTMLAttributes }) {
+        return [
+            'deletion' === mark.attrs.kind ? 'del' : 'ins',
+            mergeAttributes(HTMLAttributes, {
+                'data-document-change': 'true'
+            }),
+            0
+        ];
+    },
+    addCommands () {
+        return {
+            acceptAllDocumentChanges: ()=>(props)=>resolveDocumentChangesCommand(props, this.type, 'accept') > 0,
+            acceptDocumentChange: (id)=>(props)=>resolveDocumentChangesCommand(props, this.type, 'accept', new Set([
+                        id
+                    ])) > 0,
+            rejectAllDocumentChanges: ()=>(props)=>resolveDocumentChangesCommand(props, this.type, 'reject') > 0,
+            rejectDocumentChange: (id)=>(props)=>resolveDocumentChangesCommand(props, this.type, 'reject', new Set([
+                        id
+                    ])) > 0,
+            replaceDocumentTextWithTrackedChange: (from, to, text)=>({ state, tr })=>{
+                    if (from < 0 || to < from || to > state.doc.content.size) return false;
+                    trackedReplacement(tr, state.doc, this.type, from, to, text, this.options.createChange);
+                    return tr.docChanged;
+                },
+            setDocumentTrackChanges: (enabled)=>()=>{
+                    if (enabled !== this.options.isTracking()) this.options.onTrackingChange(enabled);
+                    return true;
+                },
+            toggleDocumentTrackChanges: ()=>()=>{
+                    this.options.onTrackingChange(!this.options.isTracking());
+                    return true;
+                }
+        };
+    },
+    addProseMirrorPlugins () {
+        const changeType = this.type;
+        const options = this.options;
+        return [
+            new Plugin({
+                key: documentChangePluginKey,
+                props: {
+                    handleTextInput: (view, from, to, text)=>{
+                        if (!options.isTracking()) return false;
+                        const transaction = trackedReplacement(view.state.tr, view.state.doc, changeType, from, to, text, options.createChange);
+                        view.dispatch(transaction);
+                        return true;
+                    },
+                    handleKeyDown: (view, event)=>{
+                        if (!options.isTracking() || event.isComposing || event.metaKey || event.ctrlKey || 'Backspace' !== event.key && 'Delete' !== event.key) return false;
+                        const selection = view.state.selection;
+                        const range = selection.from !== selection.to ? {
+                            from: selection.from,
+                            to: selection.to
+                        } : adjacentTextRange(view.state.doc, selection.from, 'Backspace' === event.key ? -1 : 1);
+                        if (!range) return false;
+                        const transaction = view.state.tr;
+                        const changed = trackDeletion(transaction, view.state.doc, changeType, range.from, range.to, changeMark(changeType, 'deletion', options.createChange));
+                        if (!changed) return false;
+                        const cursor = Math.min(transaction.doc.content.size, transaction.mapping.map(range.from));
+                        transaction.setSelection(TextSelection.near(transaction.doc.resolve(cursor)));
+                        view.dispatch(transaction);
+                        return true;
+                    },
+                    handlePaste: (view, _event, slice)=>{
+                        if (!options.isTracking()) return false;
+                        const insertion = changeMark(changeType, 'insertion', options.createChange);
+                        const markedSlice = new Slice(markFragment(slice.content, insertion, changeType), slice.openStart, slice.openEnd);
+                        const { from, to } = view.state.selection;
+                        const transaction = view.state.tr;
+                        if (from !== to) trackDeletion(transaction, view.state.doc, changeType, from, to, changeMark(changeType, 'deletion', options.createChange));
+                        const position = transaction.mapping.map(to, -1);
+                        transaction.replace(position, position, markedSlice);
+                        const cursor = Math.min(transaction.doc.content.size, position + markedSlice.size);
+                        transaction.setSelection(TextSelection.near(transaction.doc.resolve(cursor)));
+                        view.dispatch(transaction);
+                        return true;
+                    }
+                }
+            })
+        ];
+    }
+});
+function collectDocumentChanges(document1) {
+    const changes = new Map();
+    document1.descendants((node, position)=>{
+        if (!node.isText || !node.text) return;
+        const mark = documentChangeMark(node.marks);
+        if (!mark) return;
+        const kind = changeKind(mark.attrs.kind);
+        const id = stringAttribute(mark.attrs.id) || `change-at-${position}`;
+        const key = `${kind}:${id}`;
+        const current = changes.get(key);
+        if (current) {
+            current.from = Math.min(current.from, position);
+            current.to = Math.max(current.to, position + node.nodeSize);
+            current.text += node.text;
+            return;
+        }
+        changes.set(key, {
+            id,
+            kind,
+            author: stringAttribute(mark.attrs.author) || '未知审阅者',
+            date: stringAttribute(mark.attrs.date),
+            from: position,
+            to: position + node.nodeSize,
+            text: node.text
+        });
+    });
+    return Array.from(changes.values()).sort((left, right)=>left.from - right.from);
+}
+function resolveDocumentChangesCommand({ state, tr }, type, decision, ids) {
+    const segments = documentChangeSegments(state.doc, type).filter((segment)=>!ids || ids.has(segment.id));
+    if (!segments.length) return 0;
+    const removals = [];
+    const deletions = [];
+    for (const segment of segments){
+        const remove = 'accept' === decision && 'insertion' === segment.kind || 'reject' === decision && 'deletion' === segment.kind;
+        (remove ? removals : deletions).push(segment);
+    }
+    for (const segment of removals)tr.removeMark(segment.from, segment.to, type);
+    for (const segment of deletions.sort((left, right)=>right.from - left.from))tr.delete(segment.from, segment.to);
+    return tr.docChanged ? new Set(segments.map((segment)=>segment.id)).size : 0;
+}
+function trackedReplacement(transaction, document1, type, from, to, text, createChange) {
+    if (from !== to) trackDeletion(transaction, document1, type, from, to, changeMark(type, 'deletion', createChange));
+    const position = transaction.mapping.map(to, -1);
+    if (text) {
+        const insertion = from === to ? continuousInsertionMark(document1, type, position, createChange) : changeMark(type, 'insertion', createChange);
+        transaction.insertText(text, position);
+        transaction.addMark(position, position + text.length, insertion);
+    }
+    const cursor = Math.min(transaction.doc.content.size, position + text.length);
+    transaction.setSelection(TextSelection.near(transaction.doc.resolve(cursor)));
+    return transaction;
+}
+function trackDeletion(transaction, document1, type, from, to, deletion) {
+    const segments = textSegments(document1, type, from, to);
+    if (!segments.length) return false;
+    for (const segment of segments)if (!segment.kind) transaction.addMark(segment.from, segment.to, deletion);
+    for (const segment of segments.filter((segment)=>'insertion' === segment.kind).sort((left, right)=>right.from - left.from))transaction.delete(segment.from, segment.to);
+    return true;
+}
+function textSegments(document1, type, from, to) {
+    const segments = [];
+    document1.nodesBetween(from, to, (node, position)=>{
+        if (!node.isText) return;
+        const start = Math.max(from, position);
+        const end = Math.min(to, position + node.nodeSize);
+        if (start >= end) return;
+        const mark = node.marks.find((candidate)=>candidate.type === type);
+        segments.push({
+            from: start,
+            to: end,
+            kind: mark ? changeKind(mark.attrs.kind) : null
+        });
+    });
+    return segments;
+}
+function documentChangeSegments(document1, type) {
+    const segments = [];
+    document1.descendants((node, position)=>{
+        if (!node.isText) return;
+        const mark = node.marks.find((candidate)=>candidate.type === type);
+        if (!mark) return;
+        segments.push({
+            id: stringAttribute(mark.attrs.id) || `change-at-${position}`,
+            kind: changeKind(mark.attrs.kind),
+            from: position,
+            to: position + node.nodeSize
+        });
+    });
+    return segments;
+}
+function markFragment(fragment, insertion, type) {
+    const nodes = [];
+    fragment.forEach((node)=>{
+        if (node.isText) nodes.push(node.mark([
+            ...node.marks.filter((mark)=>mark.type !== type),
+            insertion
+        ]));
+        else if (node.content.size) nodes.push(node.copy(markFragment(node.content, insertion, type)));
+        else nodes.push(node);
+    });
+    return Fragment.fromArray(nodes);
+}
+function adjacentTextRange(document1, position, direction) {
+    const resolved = document1.resolve(position);
+    const node = direction < 0 ? resolved.nodeBefore : resolved.nodeAfter;
+    if (!node?.isText || !node.text) return null;
+    const character = direction < 0 ? Array.from(node.text).at(-1) : Array.from(node.text).at(0);
+    if (!character) return null;
+    return direction < 0 ? {
+        from: position - character.length,
+        to: position
+    } : {
+        from: position,
+        to: position + character.length
+    };
+}
+function changeMark(type, kind, createChange) {
+    const identity = createChange(kind);
+    return type.create({
+        kind,
+        id: identity.id || createDocumentChangeId(),
+        author: identity.author || 'A3S Work',
+        date: identity.date || new Date().toISOString()
+    });
+}
+function continuousInsertionMark(document1, type, position, createChange) {
+    const next = changeMark(type, 'insertion', createChange);
+    const previousNode = document1.resolve(position).nodeBefore;
+    const previous = previousNode?.marks.find((mark)=>mark.type === type && 'insertion' === changeKind(mark.attrs.kind));
+    if (!previous) return next;
+    if (stringAttribute(previous.attrs.author) !== stringAttribute(next.attrs.author)) return next;
+    const previousTime = Date.parse(stringAttribute(previous.attrs.date));
+    const nextTime = Date.parse(stringAttribute(next.attrs.date));
+    if (!Number.isFinite(previousTime) || !Number.isFinite(nextTime) || Math.abs(nextTime - previousTime) > CONTINUOUS_INSERTION_WINDOW_MS) return next;
+    return previous;
+}
+function documentChangeMark(marks) {
+    return marks.find((mark)=>'documentChange' === mark.type.name);
+}
+function changeKind(value) {
+    return 'deletion' === value ? 'deletion' : 'insertion';
+}
+function stringAttribute(value) {
+    return 'string' == typeof value ? value : '';
+}
+function createDocumentChangeId() {
+    const random = "u" > typeof crypto && 'function' == typeof crypto.randomUUID ? crypto.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+    return `change-${random}`;
+}
+const DocumentCitation = Node.create({
+    name: 'documentCitation',
+    inline: true,
+    group: 'inline',
+    atom: true,
+    selectable: true,
+    addOptions () {
+        return {
+            getContent: ()=>null,
+            onContentChange: ()=>void 0
+        };
+    },
+    addCommands () {
+        return {
+            insertDocumentCitation: (source, bibliography)=>(props)=>insertDocumentCitationCommand(props, source, bibliography),
+            insertDocumentBibliography: (bibliography)=>(props)=>insertDocumentBibliographyCommand(props, bibliography),
+            refreshDocumentCitations: (content)=>(props)=>refreshDocumentCitationsCommand(props, content),
+            renameDocumentCitationTag: (previousTag, nextTag)=>(props)=>renameDocumentCitationTagCommand(props, previousTag, nextTag),
+            setDocumentBibliography: (bibliography, renamedTag)=>({ dispatch, editor })=>{
+                    const content = this.options.getContent();
+                    if (!content) return false;
+                    if (!dispatch) return true;
+                    const next = {
+                        ...content,
+                        bibliography
+                    };
+                    this.options.onContentChange(next);
+                    const chain = editor.chain();
+                    if (renamedTag) chain.renameDocumentCitationTag(renamedTag.previous, renamedTag.next);
+                    chain.refreshDocumentCitations(next).run();
+                    return true;
+                }
+        };
+    },
+    addAttributes () {
+        return {
+            id: work_document_citation_nodes_hiddenAttribute(''),
+            tags: work_document_citation_nodes_hiddenAttribute(''),
+            instruction: work_document_citation_nodes_hiddenAttribute(''),
+            display: work_document_citation_nodes_hiddenAttribute(''),
+            orphaned: work_document_citation_nodes_hiddenAttribute(false)
+        };
+    },
+    parseHTML () {
+        return [
+            {
+                tag: 'span[data-document-citation]',
+                getAttrs: (node)=>{
+                    if (!(node instanceof HTMLElement)) return false;
+                    const instruction = node.dataset.citationInstruction?.trim() ?? '';
+                    const tags = documentCitationTags(node.dataset.citationTags);
+                    const resolvedTags = tags.length ? tags : documentCitationTagsFromInstruction(instruction);
+                    return {
+                        id: node.dataset.citationId ?? '',
+                        tags: resolvedTags.join(' '),
+                        instruction: instruction || documentCitationInstruction(resolvedTags),
+                        display: node.dataset.citationDisplay?.trim() || node.textContent?.trim() || '缺失引文',
+                        orphaned: 'true' === node.dataset.citationOrphaned
+                    };
+                }
+            }
+        ];
+    },
+    renderHTML ({ node, HTMLAttributes }) {
+        const tags = 'string' == typeof node.attrs.tags ? documentCitationTags(node.attrs.tags) : [];
+        const instruction = 'string' == typeof node.attrs.instruction ? node.attrs.instruction.trim() : '';
+        const display = 'string' == typeof node.attrs.display && node.attrs.display.trim() ? node.attrs.display.trim() : '缺失引文';
+        const orphaned = Boolean(node.attrs.orphaned);
+        return [
+            'span',
+            mergeAttributes(HTMLAttributes, {
+                'data-document-citation': 'true',
+                'data-citation-id': 'string' == typeof node.attrs.id ? node.attrs.id : '',
+                'data-citation-tags': tags.join(' '),
+                'data-citation-instruction': instruction || documentCitationInstruction(tags),
+                'data-citation-display': display,
+                'data-citation-orphaned': orphaned ? 'true' : void 0,
+                class: 'work-document-citation',
+                title: tags.length ? `引文：${tags.join('、')}` : '缺失引文'
+            }),
+            display
+        ];
+    },
+    renderText ({ node }) {
+        return 'string' == typeof node.attrs.display && node.attrs.display.trim() ? node.attrs.display.trim() : '缺失引文';
+    }
+});
+const DocumentBibliography = Node.create({
+    name: 'documentBibliography',
+    group: 'block',
+    content: 'block+',
+    atom: true,
+    selectable: true,
+    defining: true,
+    isolating: true,
+    addAttributes () {
+        return {
+            id: work_document_citation_nodes_hiddenAttribute('document-bibliography-1'),
+            style: work_document_citation_nodes_hiddenAttribute('apa')
+        };
+    },
+    parseHTML () {
+        return [
+            {
+                tag: 'section[data-document-bibliography]',
+                getAttrs: (node)=>{
+                    if (!(node instanceof HTMLElement)) return false;
+                    return {
+                        id: node.dataset.bibliographyId || 'document-bibliography-1',
+                        style: node.dataset.bibliographyStyle || 'apa'
+                    };
+                }
+            }
+        ];
+    },
+    renderHTML ({ node, HTMLAttributes }) {
+        return [
+            'section',
+            mergeAttributes(HTMLAttributes, {
+                'data-document-bibliography': 'true',
+                'data-bibliography-id': 'string' == typeof node.attrs.id ? node.attrs.id : 'document-bibliography-1',
+                'data-bibliography-style': 'string' == typeof node.attrs.style ? node.attrs.style : 'apa',
+                class: 'work-document-bibliography'
+            }),
+            0
+        ];
+    }
+});
+function documentCitationCount(editor) {
+    let count = 0;
+    editor.state.doc.descendants((node)=>{
+        if ('documentCitation' === node.type.name) count += 1;
+    });
+    return count;
+}
+function insertDocumentCitationCommand({ dispatch, editor, state, tr }, source, bibliography) {
+    const citationType = editor.schema.nodes.documentCitation;
+    if (!citationType || !source.tag.trim() || work_document_citation_nodes_selectionInsideNode(state, 'documentBibliography')) return false;
+    if (!dispatch) return true;
+    const instruction = documentCitationInstruction([
+        source.tag
+    ]);
+    const resolved = resolveDocumentCitation([
+        source.tag
+    ], bibliography, instruction);
+    tr.replaceSelectionWith(citationType.create({
+        id: createWorkId('citation'),
+        tags: source.tag,
+        instruction,
+        display: resolved.text,
+        orphaned: resolved.orphaned
+    }), false);
+    tr.scrollIntoView();
+    return true;
+}
+function insertDocumentBibliographyCommand({ dispatch, editor, state, tr }, bibliography) {
+    if (!editor.schema.nodes.documentBibliography) return false;
+    const existing = documentBibliographyNodes(state.doc)[0];
+    if (!dispatch) return true;
+    if (existing) {
+        refreshDocumentCitationsInTransaction(editor, tr, bibliography);
+        tr.setSelection(NodeSelection.create(tr.doc, existing.position));
+        tr.scrollIntoView();
+        return true;
+    }
+    const replacement = bibliographyNode(editor, bibliography, createWorkId('bibliography'));
+    if (!replacement) return false;
+    tr.replaceSelectionWith(replacement);
+    const paragraphType = editor.schema.nodes.paragraph;
+    if (paragraphType && tr.selection.$to.parent.type === replacement.type) tr.insert(tr.selection.to, paragraphType.create());
+    tr.scrollIntoView();
+    return true;
+}
+function refreshDocumentCitationsCommand({ editor, tr }, content) {
+    return refreshDocumentCitationsInTransaction(editor, tr, content.bibliography);
+}
+function renameDocumentCitationTagCommand({ tr }, previousTag, nextTag) {
+    if (!previousTag || previousTag === nextTag) return false;
+    const document1 = tr.doc;
+    document1.descendants((node, position)=>{
+        if ('documentCitation' !== node.type.name) return;
+        const tags = documentCitationTags('string' == typeof node.attrs.tags ? node.attrs.tags : '');
+        if (!tags.includes(previousTag)) return;
+        const renamed = tags.map((tag)=>tag === previousTag ? nextTag : tag);
+        const instruction = 'string' == typeof node.attrs.instruction ? renameDocumentCitationTagInInstruction(node.attrs.instruction, previousTag, nextTag) : documentCitationInstruction(renamed);
+        tr.setNodeMarkup(position, void 0, {
+            ...node.attrs,
+            tags: renamed.join(' '),
+            instruction
+        });
+    });
+    return tr.docChanged;
+}
+function refreshDocumentCitationsInTransaction(editor, tr, bibliography) {
+    const document1 = tr.doc;
+    const bibliographyNodes = [];
+    document1.descendants((node, position)=>{
+        if ('documentCitation' === node.type.name) {
+            const tags = documentCitationTags('string' == typeof node.attrs.tags ? node.attrs.tags : '');
+            const instruction = 'string' == typeof node.attrs.instruction ? node.attrs.instruction : '';
+            const cached = 'string' == typeof node.attrs.display ? node.attrs.display : '';
+            const resolved = resolveDocumentCitation(tags, bibliography, instruction, cached);
+            if (node.attrs.display !== resolved.text || Boolean(node.attrs.orphaned) !== resolved.orphaned) tr.setNodeMarkup(position, void 0, {
+                ...node.attrs,
+                display: resolved.text,
+                orphaned: resolved.orphaned
+            });
+            return;
+        }
+        if ('documentBibliography' === node.type.name) bibliographyNodes.push({
+            node,
+            position
+        });
+    });
+    if (bibliography) for (const current of bibliographyNodes.reverse()){
+        const id = 'string' == typeof current.node.attrs.id ? current.node.attrs.id : 'document-bibliography-1';
+        const replacement = bibliographyNode(editor, bibliography, id);
+        if (replacement && !current.node.eq(replacement)) tr.replaceWith(current.position, current.position + current.node.nodeSize, replacement);
+    }
+    return tr.docChanged;
+}
+function bibliographyNode(editor, bibliography, id) {
+    const document1 = new DOMParser().parseFromString(renderDocumentBibliographyHtml(bibliography, id), 'text/html');
+    const slice = model_DOMParser.fromSchema(editor.schema).parseSlice(document1.body);
+    return slice.content.firstChild?.type.name === 'documentBibliography' ? slice.content.firstChild : null;
+}
+function documentBibliographyNodes(document1) {
+    const result = [];
+    document1.descendants((node, position)=>{
+        if ('documentBibliography' === node.type.name) result.push({
+            node,
+            position
+        });
+    });
+    return result;
+}
+function work_document_citation_nodes_selectionInsideNode(state, nodeName) {
+    for(let depth = state.selection.$from.depth; depth > 0; depth -= 1)if (state.selection.$from.node(depth).type.name === nodeName) return true;
+    return false;
+}
+function work_document_citation_nodes_hiddenAttribute(defaultValue) {
+    return {
+        default: defaultValue,
+        rendered: false
+    };
+}
+const documentCommentPastePluginKey = new PluginKey('documentCommentPaste');
+const documentCommentDraftPluginKey = new PluginKey('documentCommentDraft');
+const DocumentComment = Mark.create({
+    name: 'documentComment',
+    priority: 1050,
+    inclusive: false,
+    keepOnSplit: true,
+    excludes: '',
+    addOptions () {
+        return {
+            getContent: ()=>null,
+            onContentChange: ()=>void 0
+        };
+    },
+    addAttributes () {
+        return {
+            id: {
+                default: '',
+                parseHTML: (element)=>element.getAttribute('data-comment-id') ?? '',
+                renderHTML: (attributes)=>({
+                        'data-comment-id': attributes.id
+                    })
+            }
+        };
+    },
+    parseHTML () {
+        return [
+            {
+                tag: 'span[data-document-comment]'
+            }
+        ];
+    },
+    renderHTML ({ HTMLAttributes }) {
+        return [
+            'span',
+            mergeAttributes(HTMLAttributes, {
+                'data-document-comment': 'true'
+            }),
+            0
+        ];
+    },
+    addCommands () {
+        return {
+            addDocumentCommentReply: (id, reply)=>({ dispatch })=>{
+                    const content = this.options.getContent();
+                    if (!content || !(content.comments ?? []).some((comment)=>comment.id === id)) return false;
+                    if (dispatch) this.options.onContentChange({
+                        ...content,
+                        comments: appendDocumentCommentReply(content.comments ?? [], id, reply)
+                    });
+                    return true;
+                },
+            deleteDocumentComment: (id)=>({ state, dispatch })=>{
+                    const commentId = id.trim();
+                    const content = this.options.getContent();
+                    if (!commentId || !content) return false;
+                    const comments = content.comments ?? [];
+                    const hasRecord = comments.some((comment)=>comment.id === commentId);
+                    const segments = documentCommentSegments(state.doc, this.type).filter((segment)=>segment.id === commentId);
+                    if (!hasRecord && !segments.length) return false;
+                    if (!dispatch) return true;
+                    this.options.onContentChange({
+                        ...content,
+                        comments: removeDocumentCommentRecord(comments, commentId)
+                    });
+                    if (segments.length) {
+                        const transaction = state.tr;
+                        for (const segment of segments)transaction.removeMark(segment.from, segment.to, this.type);
+                        if (transaction.docChanged) dispatch(transaction);
+                    }
+                    return true;
+                },
+            showDocumentCommentDraft: (range)=>({ state, dispatch })=>{
+                    const normalized = normalizeDocumentCommentRange(state.doc, range);
+                    if (!normalized || !canInsertDocumentCommentInState(state.doc, this.type, normalized)) return false;
+                    dispatch?.(state.tr.setMeta(documentCommentDraftPluginKey, {
+                        range: normalized
+                    }));
+                    return true;
+                },
+            clearDocumentCommentDraft: ()=>({ state, dispatch })=>{
+                    if (!documentCommentDraftRangeFromState(state)) return false;
+                    dispatch?.(state.tr.setMeta(documentCommentDraftPluginKey, {
+                        range: null
+                    }));
+                    return true;
+                },
+            insertDocumentComment: ({ id, range })=>({ state, dispatch })=>{
+                    const normalized = normalizeDocumentCommentRange(state.doc, range ?? state.selection);
+                    const commentId = id.trim();
+                    if (!normalized || !commentId || !canInsertDocumentCommentInState(state.doc, this.type, normalized)) return false;
+                    const transaction = state.tr.addMark(normalized.from, normalized.to, this.type.create({
+                        id: commentId
+                    }));
+                    if (!transaction.docChanged) return false;
+                    transaction.setMeta(documentCommentDraftPluginKey, {
+                        range: null
+                    });
+                    dispatch?.(transaction);
+                    return true;
+                },
+            insertDocumentCommentThread: (comment, range)=>({ state, dispatch })=>{
+                    const content = this.options.getContent();
+                    const normalized = normalizeDocumentCommentRange(state.doc, range ?? state.selection);
+                    const commentId = comment.id.trim();
+                    if (!content || !normalized || !commentId || (content.comments ?? []).some((candidate)=>candidate.id === commentId) || !canInsertDocumentCommentInState(state.doc, this.type, normalized)) return false;
+                    if (!dispatch) return true;
+                    this.options.onContentChange({
+                        ...content,
+                        comments: [
+                            ...content.comments ?? [],
+                            comment
+                        ]
+                    });
+                    const transaction = state.tr.addMark(normalized.from, normalized.to, this.type.create({
+                        id: commentId
+                    }));
+                    transaction.setMeta(documentCommentDraftPluginKey, {
+                        range: null
+                    });
+                    dispatch(transaction);
+                    return true;
+                },
+            removeDocumentComment: (id)=>({ state, dispatch })=>{
+                    const commentId = id.trim();
+                    if (!commentId) return false;
+                    const segments = documentCommentSegments(state.doc, this.type).filter((segment)=>segment.id === commentId);
+                    if (!segments.length) return false;
+                    const transaction = state.tr;
+                    for (const segment of segments)transaction.removeMark(segment.from, segment.to, this.type);
+                    if (!transaction.docChanged) return false;
+                    dispatch?.(transaction);
+                    return true;
+                },
+            toggleDocumentCommentResolved: (id)=>({ dispatch })=>{
+                    const content = this.options.getContent();
+                    if (!content || !(content.comments ?? []).some((comment)=>comment.id === id)) return false;
+                    if (dispatch) this.options.onContentChange({
+                        ...content,
+                        comments: toggleDocumentCommentResolved(content.comments ?? [], id)
+                    });
+                    return true;
+                }
+        };
+    },
+    addProseMirrorPlugins () {
+        const type = this.type;
+        return [
+            new Plugin({
+                key: documentCommentPastePluginKey,
+                props: {
+                    transformPasted: (slice)=>stripDocumentCommentsFromSlice(slice, type)
+                }
+            }),
+            new Plugin({
+                key: documentCommentDraftPluginKey,
+                state: {
+                    init: ()=>DecorationSet.empty,
+                    apply: (transaction, current)=>{
+                        const mapped = current.map(transaction.mapping, transaction.doc);
+                        const meta = transaction.getMeta(documentCommentDraftPluginKey);
+                        if (!meta) return mapped;
+                        const range = normalizeDocumentCommentRange(transaction.doc, meta.range);
+                        if (!range) return DecorationSet.empty;
+                        return DecorationSet.create(transaction.doc, [
+                            Decoration.inline(range.from, range.to, {
+                                class: 'work-document-comment-draft',
+                                'data-document-comment-draft': 'true'
+                            }, {
+                                inclusiveStart: false,
+                                inclusiveEnd: false
+                            })
+                        ]);
+                    }
+                },
+                props: {
+                    decorations: (state)=>documentCommentDraftPluginKey.getState(state) ?? DecorationSet.empty
+                }
+            })
+        ];
+    }
+});
+function canInsertDocumentComment(editor, range = editor.state.selection) {
+    const type = editor.schema.marks.documentComment;
+    return canInsertDocumentCommentInState(editor.state.doc, type, range);
+}
+function documentCommentDraftRange(editor) {
+    return documentCommentDraftRangeFromState(editor.state);
+}
+function documentCommentDraftRangeFromState(state) {
+    const decorations = documentCommentDraftPluginKey.getState(state)?.find();
+    if (!decorations?.length) return null;
+    return {
+        from: Math.min(...decorations.map((decoration)=>decoration.from)),
+        to: Math.max(...decorations.map((decoration)=>decoration.to))
+    };
+}
+function collectDocumentCommentAnchors(document1) {
+    const anchors = new Map();
+    document1.descendants((node, position)=>{
+        if (!node.isText || !node.text) return;
+        const mark = documentCommentMark(node.marks);
+        const id = mark ? work_document_comments_stringAttribute(mark.attrs.id).trim() : '';
+        if (!id) return;
+        const current = anchors.get(id);
+        if (current) {
+            current.from = Math.min(current.from, position);
+            current.to = Math.max(current.to, position + node.nodeSize);
+            current.anchorText += node.text;
+            return;
+        }
+        anchors.set(id, {
+            id,
+            from: position,
+            to: position + node.nodeSize,
+            anchorText: node.text
+        });
+    });
+    return Array.from(anchors.values()).sort((left, right)=>left.from - right.from);
+}
+function documentCommentViews(comments, anchors) {
+    const byId = new Map(comments.map((comment)=>[
+            comment.id,
+            normalizeDocumentComment(comment)
+        ]));
+    return anchors.map((anchor)=>({
+            ...byId.get(anchor.id) ?? {
+                id: anchor.id,
+                author: '未知审阅者',
+                date: '',
+                text: '此批注的内容不可用。',
+                resolved: false
+            },
+            ...anchor
+        }));
+}
+function retainAnchoredDocumentComments(comments, anchors) {
+    const ids = new Set(anchors.map((anchor)=>anchor.id));
+    return comments.filter((comment)=>ids.has(comment.id)).map(normalizeDocumentComment);
+}
+function appendDocumentCommentReply(comments, id, reply) {
+    return comments.map((comment)=>comment.id === id ? {
+            ...comment,
+            replies: [
+                ...comment.replies ?? [],
+                reply
+            ]
+        } : comment);
+}
+function toggleDocumentCommentResolved(comments, id) {
+    return comments.map((comment)=>comment.id === id ? {
+            ...comment,
+            resolved: !comment.resolved
+        } : comment);
+}
+function removeDocumentCommentRecord(comments, id) {
+    return comments.filter((comment)=>comment.id !== id);
+}
+function stripDocumentCommentsFromSlice(slice, type) {
+    return new Slice(stripDocumentCommentMarks(slice.content, type), slice.openStart, slice.openEnd);
+}
+function selectionContainsDocumentComment(document1, from, to) {
+    let found = false;
+    document1.nodesBetween(from, to, (node)=>{
+        if (node.isText && documentCommentMark(node.marks)) found = true;
+        return !found;
+    });
+    return found;
+}
+function canInsertDocumentCommentInState(document1, type, range) {
+    const normalized = normalizeDocumentCommentRange(document1, range);
+    if (!type || !normalized) return false;
+    const selectedText = document1.textBetween(normalized.from, normalized.to, '\n');
+    return Boolean(selectedText.trim()) && !selectionContainsDocumentComment(document1, normalized.from, normalized.to);
+}
+function normalizeDocumentCommentRange(document1, range) {
+    if (!range) return null;
+    const from = Math.max(0, Math.min(document1.content.size, range.from));
+    const to = Math.max(0, Math.min(document1.content.size, range.to));
+    return from < to ? {
+        from,
+        to
+    } : null;
+}
+function documentCommentSegments(document1, type) {
+    const segments = [];
+    document1.descendants((node, position)=>{
+        if (!node.isText) return;
+        const mark = node.marks.find((candidate)=>candidate.type === type);
+        const id = mark ? work_document_comments_stringAttribute(mark.attrs.id).trim() : '';
+        if (id) segments.push({
+            id,
+            from: position,
+            to: position + node.nodeSize
+        });
+    });
+    return segments;
+}
+function stripDocumentCommentMarks(fragment, type) {
+    const nodes = [];
+    fragment.forEach((node)=>{
+        const content = node.content.size ? stripDocumentCommentMarks(node.content, type) : node.content;
+        const copy = node.content.size ? node.copy(content) : node;
+        nodes.push(copy.mark(copy.marks.filter((mark)=>mark.type !== type)));
+    });
+    return Fragment.fromArray(nodes);
+}
+function documentCommentMark(marks) {
+    return marks.find((mark)=>'documentComment' === mark.type.name);
+}
+function normalizeDocumentComment(comment) {
+    return {
+        id: comment.id,
+        author: comment.author || '未知审阅者',
+        date: comment.date || '',
+        text: comment.text || '（空批注）',
+        resolved: Boolean(comment.resolved),
+        replies: comment.replies?.map((reply)=>({
+                id: reply.id,
+                author: reply.author || '未知审阅者',
+                date: reply.date || '',
+                text: reply.text || '（空回复）'
+            }))
+    };
+}
+function work_document_comments_stringAttribute(value) {
+    return 'string' == typeof value ? value : '';
+}
+function documentPageDescriptors(content) {
+    const noteCollection = collectDocumentNotes(content.html);
+    const canonicalContent = {
+        ...content,
+        html: noteCollection.html
+    };
+    const sections = documentSections(canonicalContent);
+    const pages = [];
+    let nextPageNumber = sections[0]?.layout.pageNumberStart ?? 1;
+    let currentPage = null;
+    sections.forEach((section, sectionIndex)=>{
+        const parts = safeSectionPages(section.html);
+        const previousBreak = sectionIndex > 0 ? sections[sectionIndex - 1].layout.breakAfter : null;
+        const restartsNumbering = void 0 !== section.layout.pageNumberStart;
+        const continuesCurrentPage = sectionIndex > 0 && !restartsNumbering && ('continuous' === previousBreak || 'nextColumn' === previousBreak) && null !== currentPage && samePhysicalPageLayout(currentPage.layout, section.layout);
+        let sectionPage = continuesCurrentPage ? 1 : 0;
+        if (!continuesCurrentPage) {
+            if ('evenPage' === previousBreak || 'oddPage' === previousBreak) {
+                const desiredParity = 'evenPage' === previousBreak ? 0 : 1;
+                const nextPhysicalPage = pages.length + 1;
+                if (nextPhysicalPage % 2 !== desiredParity) {
+                    pages.push(createPage(section.layout, nextPageNumber, pages.length + 1, 0, true));
+                    nextPageNumber += 1;
+                }
+            }
+            if (restartsNumbering) nextPageNumber = section.layout.pageNumberStart ?? nextPageNumber;
+            sectionPage = 1;
+            currentPage = createPage(section.layout, nextPageNumber, pages.length + 1, sectionPage, false);
+            pages.push(currentPage);
+            nextPageNumber += 1;
+        }
+        parts.forEach((html, partIndex)=>{
+            if (partIndex > 0) {
+                sectionPage += 1;
+                currentPage = createPage(section.layout, nextPageNumber, pages.length + 1, sectionPage, false);
+                pages.push(currentPage);
+                nextPageNumber += 1;
+            }
+            currentPage?.segments.push({
+                sectionId: section.id,
+                html,
+                columns: section.layout.columns
+            });
+        });
+    });
+    const result = pages.length ? pages : [
+        createPage(documentSections(content)[0]?.layout, content.pageNumberStart ?? 1, 1, 1, false)
+    ];
+    resolveDocumentPageFields(result, sections);
+    attachDocumentNotes(result, noteCollection.notes);
+    return result;
+}
+function resolveDocumentPageFields(pages, sections) {
+    const sectionNumbers = new Map(sections.map((section, index)=>[
+            section.id,
+            index + 1
+        ]));
+    const sectionPages = new Map();
+    for (const page of pages)for (const sectionId of new Set(page.segments.map((segment)=>segment.sectionId)))sectionPages.set(sectionId, (sectionPages.get(sectionId) ?? 0) + 1);
+    const now = new Date();
+    for (const page of pages)for (const segment of page.segments)segment.html = resolveDocumentFieldsHtml(segment.html, {
+        pageNumber: page.pageNumber,
+        totalPages: pages.length,
+        sectionNumber: sectionNumbers.get(segment.sectionId) ?? 1,
+        sectionPages: sectionPages.get(segment.sectionId) ?? 1,
+        now
+    });
+}
+function samePhysicalPageLayout(current, next) {
+    return current.pageSize === next.pageSize && current.orientation === next.orientation && current.margins.top === next.margins.top && current.margins.right === next.margins.right && current.margins.bottom === next.margins.bottom && current.margins.left === next.margins.left;
+}
+function createPage(layout, pageNumber, physicalPage, sectionPage, blank) {
+    const effectiveLayout = layout ?? {
+        pageSize: 'a4',
+        orientation: 'portrait',
+        margins: {
+            top: 25,
+            right: 23,
+            bottom: 25,
+            left: 23
+        },
+        columns: {
+            count: 1,
+            spacing: 12,
+            separator: false
+        },
+        breakAfter: 'nextPage'
+    };
+    return {
+        key: `document-page-${physicalPage}`,
+        layout: effectiveLayout,
+        segments: [],
+        pageNumber,
+        physicalPage,
+        sectionPage,
+        blank,
+        footnotes: [],
+        endnotes: []
+    };
+}
+function safeSectionPages(source) {
+    const document1 = new DOMParser().parseFromString(removeDocumentNoteDefinitions(source), 'text/html');
+    sanitizeDocument(document1);
+    const pages = [
+        document1.createElement('div')
+    ];
+    for (const node of Array.from(document1.body.childNodes)){
+        if (node instanceof Element && node.hasAttribute('data-page-break')) {
+            pages.push(document1.createElement('div'));
+            continue;
+        }
+        pages.at(-1)?.append(node.cloneNode(true));
+    }
+    return pages.map((page)=>page.innerHTML);
+}
+function sanitizeDocument(document1) {
+    for (const element of Array.from(document1.body.querySelectorAll("script, iframe, object, embed, link, meta")))element.remove();
+    for (const element of Array.from(document1.body.querySelectorAll('*'))){
+        for (const attribute of Array.from(element.attributes))if (attribute.name.toLowerCase().startsWith('on')) element.removeAttribute(attribute.name);
+        if (element instanceof HTMLAnchorElement && /^(?:javascript|vbscript|data):/i.test(element.getAttribute('href')?.trim() ?? '')) element.removeAttribute('href');
+    }
+}
+function attachDocumentNotes(pages, notes) {
+    const safeNotes = notes.map((note)=>({
+            ...note,
+            html: safeNoteHtml(note.html)
+        }));
+    const byKey = new Map(safeNotes.map((note)=>[
+            documentNoteKey(note.kind, note.id),
+            note
+        ]));
+    for (const page of pages){
+        const keys = new Set(page.segments.flatMap((segment)=>documentNoteReferenceKeys(segment.html)));
+        page.footnotes = Array.from(keys).map((key)=>byKey.get(key)).filter((note)=>note?.kind === 'footnote');
+    }
+    const lastContentPage = [
+        ...pages
+    ].reverse().find((page)=>!page.blank);
+    if (lastContentPage) lastContentPage.endnotes = safeNotes.filter((note)=>'endnote' === note.kind);
+}
+function safeNoteHtml(source) {
+    const document1 = new DOMParser().parseFromString(source, 'text/html');
+    sanitizeDocument(document1);
+    return document1.body.innerHTML;
+}
+const DocumentField = Node.create({
+    name: 'documentField',
+    inline: true,
+    group: 'inline',
+    atom: true,
+    selectable: true,
+    addCommands () {
+        return {
+            insertDocumentField: (kind)=>(props)=>insertDocumentFieldCommand(props, kind),
+            refreshDocumentFields: (content)=>(props)=>refreshDocumentFieldsCommand(props, content)
+        };
+    },
+    addAttributes () {
+        return {
+            id: work_document_field_node_hiddenAttribute(''),
+            kind: work_document_field_node_hiddenAttribute('page'),
+            instruction: work_document_field_node_hiddenAttribute('PAGE'),
+            display: work_document_field_node_hiddenAttribute('1')
+        };
+    },
+    parseHTML () {
+        return [
+            {
+                tag: 'span[data-document-field]',
+                getAttrs: (node)=>{
+                    if (!(node instanceof HTMLElement)) return false;
+                    const instruction = node.dataset.fieldInstruction?.trim() ?? '';
+                    const kind = documentFieldKind(node.dataset.fieldKind) ?? docxDocumentFieldKind(instruction) ?? 'page';
+                    return {
+                        id: node.dataset.fieldId ?? '',
+                        kind,
+                        instruction: instruction || documentFieldInstruction(kind),
+                        display: node.dataset.fieldDisplay?.trim() || node.textContent?.trim() || documentFieldLabel(kind)
+                    };
+                }
+            }
+        ];
+    },
+    renderHTML ({ node, HTMLAttributes }) {
+        const instruction = 'string' == typeof node.attrs.instruction ? node.attrs.instruction.trim() : '';
+        const kind = documentFieldKind(node.attrs.kind) ?? docxDocumentFieldKind(instruction) ?? 'page';
+        const display = 'string' == typeof node.attrs.display && node.attrs.display.trim() ? node.attrs.display.trim() : documentFieldLabel(kind);
+        return [
+            'span',
+            mergeAttributes(HTMLAttributes, {
+                'data-document-field': 'true',
+                'data-field-id': 'string' == typeof node.attrs.id ? node.attrs.id : '',
+                'data-field-kind': kind,
+                'data-field-instruction': instruction || documentFieldInstruction(kind),
+                'data-field-display': display,
+                class: 'work-document-field',
+                title: documentFieldLabel(kind)
+            }),
+            display
+        ];
+    },
+    renderText ({ node }) {
+        const kind = documentFieldKind(node.attrs.kind) ?? 'page';
+        return 'string' == typeof node.attrs.display && node.attrs.display.trim() ? node.attrs.display.trim() : documentFieldLabel(kind);
+    }
+});
+function insertDocumentFieldCommand({ dispatch, editor, state, tr }, kind) {
+    const fieldType = editor.schema.nodes.documentField;
+    if (!fieldType) return false;
+    if (!dispatch) return true;
+    const instruction = documentFieldInstruction(kind);
+    tr.replaceSelectionWith(fieldType.create({
+        id: createWorkId('field'),
+        kind,
+        instruction,
+        display: documentFieldDisplay(kind, fallbackContext(state), instruction)
+    }), false);
+    tr.scrollIntoView();
+    return true;
+}
+function refreshDocumentFieldsCommand({ editor, state, tr }, content) {
+    const canonical = syncDocumentContentFromHtml(content, editor.getHTML());
+    const displays = documentPageDescriptors(canonical).flatMap((page)=>page.segments.flatMap((segment)=>{
+            const document1 = new DOMParser().parseFromString(segment.html, 'text/html');
+            return Array.from(document1.body.querySelectorAll('[data-document-field]')).map((element)=>element.dataset.fieldDisplay?.trim() || element.textContent?.trim() || '');
+        }));
+    let fieldIndex = 0;
+    state.doc.descendants((node, position)=>{
+        if ('documentField' !== node.type.name) return;
+        const display = displays[fieldIndex];
+        fieldIndex += 1;
+        if (!display || node.attrs.display === display) return;
+        tr.setNodeMarkup(position, void 0, {
+            ...node.attrs,
+            display
+        });
+    });
+    return tr.docChanged;
+}
+function fallbackContext(state) {
+    let totalPages = 0;
+    let sectionNumber = 1;
+    let sectionPages = 1;
+    let pageNumber = 1;
+    let pagesBeforeSelection = 0;
+    let foundSelection = false;
+    state.doc.forEach((section, offset, index)=>{
+        if ('documentSection' !== section.type.name) return;
+        const pages = countPageBreaks(section) + 1;
+        totalPages += pages;
+        if (!foundSelection && state.selection.from <= offset + section.nodeSize) {
+            sectionNumber = index + 1;
+            sectionPages = pages;
+            pageNumber = pagesBeforeSelection + 1 + countPageBreaksBefore(section, state.selection.from - offset - 1);
+            foundSelection = true;
+        }
+        if (!foundSelection) pagesBeforeSelection += pages;
+    });
+    return {
+        pageNumber,
+        totalPages: Math.max(1, totalPages),
+        sectionNumber,
+        sectionPages
+    };
+}
+function countPageBreaks(node) {
+    let count = 0;
+    node.descendants((child)=>{
+        if ('pageBreak' === child.type.name) count += 1;
+    });
+    return count;
+}
+function countPageBreaksBefore(node, position) {
+    let count = 0;
+    node.descendants((child, offset)=>{
+        if (offset >= position) return false;
+        if ('pageBreak' === child.type.name) count += 1;
+        return true;
+    });
+    return count;
+}
+function work_document_field_node_hiddenAttribute(defaultValue) {
+    return {
+        default: defaultValue,
+        rendered: false
+    };
+}
+const MAX_DOCUMENT_NUMBERING_START = 2147483647;
+const DocumentBulletList = BulletList.extend({
+    addAttributes () {
+        return {
+            bulletStyle: {
+                default: 'disc',
+                parseHTML: (element)=>parsedBulletStyle(element) ?? 'disc',
+                renderHTML: (attributes)=>{
+                    const style = normalizeBulletStyle(attributes.bulletStyle) ?? 'disc';
+                    return 'disc' === style ? {} : {
+                        'data-office-bullet-style': style,
+                        style: `list-style-type: ${style}`
+                    };
+                }
+            }
+        };
+    }
+});
+const DocumentOrderedList = OrderedList;
+const DocumentListCommands = Extension.create({
+    name: 'documentListCommands',
+    addCommands () {
+        return {
+            applyDocumentBulletList: (style)=>(props)=>applyDocumentBulletList(props, style),
+            applyDocumentOrderedList: (style)=>(props)=>applyDocumentOrderedList(props, style),
+            clearDocumentList: ()=>(props)=>clearDocumentList(props),
+            continueDocumentNumbering: ()=>(props)=>continueDocumentNumbering(props),
+            restartDocumentNumbering: ()=>(props)=>setDocumentNumberingStart(props, 1),
+            setDocumentNumberingStart: (start)=>(props)=>setDocumentNumberingStart(props, start)
+        };
+    }
+});
+function documentBulletListStyle(editor) {
+    const active = activeList(editor.state, 'bulletList');
+    if (!active) return null;
+    return normalizeBulletStyle(active.node.attrs.bulletStyle) ?? 'disc';
+}
+function documentOrderedListState(editor) {
+    const active = activeList(editor.state, 'orderedList');
+    if (!active) return null;
+    return {
+        start: normalizedNumberingStart(active.node.attrs.start),
+        style: orderedListStyle(active.node.attrs.type)
+    };
+}
+function applyDocumentBulletList(props, style) {
+    const normalized = normalizeBulletStyle(style);
+    if (!normalized) return false;
+    const current = activeList(props.state, 'bulletList');
+    if (current) return updateListAttributes(props, current, {
+        bulletStyle: normalized
+    });
+    return props.chain().toggleBulletList().updateAttributes('bulletList', {
+        bulletStyle: normalized
+    }).run();
+}
+function applyDocumentOrderedList(props, style) {
+    const type = orderedListType(style);
+    if (void 0 === type) return false;
+    const current = activeList(props.state, 'orderedList');
+    if (current) return updateListAttributes(props, current, {
+        type
+    });
+    return props.chain().toggleOrderedList().updateAttributes('orderedList', {
+        start: 1,
+        type
+    }).run();
+}
+function clearDocumentList(props) {
+    if (activeList(props.state, 'bulletList')) return props.commands.toggleBulletList();
+    if (activeList(props.state, 'orderedList')) return props.commands.toggleOrderedList();
+    return false;
+}
+function setDocumentNumberingStart(props, start) {
+    if (!validNumberingStart(start)) return false;
+    const current = activeList(props.state, 'orderedList');
+    if (!current) return false;
+    return updateListAttributes(props, current, {
+        start
+    });
+}
+function continueDocumentNumbering(props) {
+    const current = activeList(props.state, 'orderedList');
+    if (!current) return false;
+    const previous = precedingOrderedList(props.state.doc, current);
+    if (!previous) return false;
+    const start = Math.min(MAX_DOCUMENT_NUMBERING_START, normalizedNumberingStart(previous.node.attrs.start) + previous.node.childCount);
+    return updateListAttributes(props, current, {
+        start,
+        type: normalizedOrderedListType(previous.node.attrs.type)
+    });
+}
+function updateListAttributes({ dispatch, state }, list, attributes) {
+    const next = {
+        ...list.node.attrs,
+        ...attributes
+    };
+    if (Object.entries(attributes).every(([key, value])=>list.node.attrs[key] === value)) return true;
+    dispatch?.(state.tr.setNodeMarkup(list.position, void 0, next, list.node.marks).scrollIntoView());
+    return true;
+}
+function activeList(state, nodeName) {
+    const position = state.selection.$from;
+    for(let depth = position.depth; depth > 0; depth -= 1){
+        const node = position.node(depth);
+        if (node.type.name === nodeName) return {
+            depth,
+            node,
+            position: position.before(depth)
+        };
+    }
+    return null;
+}
+function precedingOrderedList(document1, current) {
+    let previous = null;
+    document1.descendants((node, position)=>{
+        if (position >= current.position) return false;
+        if ('orderedList' !== node.type.name) return true;
+        const parentDepth = document1.resolve(position).depth;
+        if (parentDepth === current.depth - 1) previous = {
+            depth: parentDepth + 1,
+            node,
+            position
+        };
+        return true;
+    });
+    return previous;
+}
+function parsedBulletStyle(element) {
+    const direct = element.dataset.officeBulletStyle || element.style.listStyleType;
+    const fromList = normalizeBulletStyle(direct);
+    if (fromList) return fromList;
+    return normalizeBulletStyle(element.querySelector(':scope > li')?.style.listStyleType);
+}
+function normalizeBulletStyle(value) {
+    return 'disc' === value || 'circle' === value || 'square' === value ? value : null;
+}
+function orderedListType(style) {
+    if ('decimal' === style) return null;
+    if ('lower-alpha' === style) return 'a';
+    if ('upper-alpha' === style) return 'A';
+    if ('lower-roman' === style) return 'i';
+    if ('upper-roman' === style) return 'I';
+}
+function orderedListStyle(value) {
+    const type = normalizedOrderedListType(value);
+    if ('a' === type) return 'lower-alpha';
+    if ('A' === type) return 'upper-alpha';
+    if ('i' === type) return 'lower-roman';
+    if ('I' === type) return 'upper-roman';
+    return 'decimal';
+}
+function normalizedOrderedListType(value) {
+    return 'a' === value || 'A' === value || 'i' === value || 'I' === value ? value : null;
+}
+function normalizedNumberingStart(value) {
+    const start = Number(value);
+    return validNumberingStart(start) ? start : 1;
+}
+function validNumberingStart(value) {
+    return Number.isSafeInteger(value) && value >= 1 && value <= MAX_DOCUMENT_NUMBERING_START;
+}
+const DocumentNoteReference = Node.create({
+    name: 'documentNoteReference',
+    inline: true,
+    group: 'inline',
+    atom: true,
+    selectable: true,
+    addCommands () {
+        return {
+            insertDocumentNote: (kind)=>(props)=>insertDocumentNoteCommand(props, kind)
+        };
+    },
+    addAttributes () {
+        return {
+            id: work_document_note_nodes_hiddenAttribute(''),
+            kind: work_document_note_nodes_hiddenAttribute('footnote'),
+            number: work_document_note_nodes_hiddenAttribute(1)
+        };
+    },
+    parseHTML () {
+        return [
+            {
+                tag: 'sup[data-document-note-reference]',
+                getAttrs: (node)=>{
+                    if (!(node instanceof HTMLElement)) return false;
+                    return {
+                        id: node.dataset.noteId ?? '',
+                        kind: documentNoteKind(node.dataset.noteKind) ?? 'footnote',
+                        number: work_document_note_nodes_positiveInteger(node.dataset.noteNumber)
+                    };
+                }
+            }
+        ];
+    },
+    renderHTML ({ node, HTMLAttributes }) {
+        const kind = documentNoteKind(node.attrs.kind) ?? 'footnote';
+        const number = work_document_note_nodes_positiveInteger(node.attrs.number);
+        return [
+            'sup',
+            mergeAttributes(HTMLAttributes, {
+                'data-document-note-reference': 'true',
+                'data-note-kind': kind,
+                'data-note-id': 'string' == typeof node.attrs.id ? node.attrs.id : '',
+                'data-note-number': String(number),
+                class: 'work-document-note-reference'
+            }),
+            String(number)
+        ];
+    },
+    renderText ({ node }) {
+        return String(work_document_note_nodes_positiveInteger(node.attrs.number));
+    }
+});
+const DocumentNote = Node.create({
+    name: 'documentNote',
+    group: 'block',
+    content: 'block+',
+    defining: true,
+    isolating: true,
+    addAttributes () {
+        return {
+            id: work_document_note_nodes_hiddenAttribute(''),
+            kind: work_document_note_nodes_hiddenAttribute('footnote'),
+            number: work_document_note_nodes_hiddenAttribute(1)
+        };
+    },
+    parseHTML () {
+        return [
+            {
+                tag: 'aside[data-document-note]',
+                getAttrs: (node)=>{
+                    if (!(node instanceof HTMLElement)) return false;
+                    return {
+                        id: node.dataset.noteId ?? '',
+                        kind: documentNoteKind(node.dataset.noteKind) ?? 'footnote',
+                        number: work_document_note_nodes_positiveInteger(node.dataset.noteNumber)
+                    };
+                }
+            }
+        ];
+    },
+    renderHTML ({ node, HTMLAttributes }) {
+        const kind = documentNoteKind(node.attrs.kind) ?? 'footnote';
+        const number = work_document_note_nodes_positiveInteger(node.attrs.number);
+        return [
+            'aside',
+            mergeAttributes(HTMLAttributes, {
+                'data-document-note': 'true',
+                'data-note-kind': kind,
+                'data-note-id': 'string' == typeof node.attrs.id ? node.attrs.id : '',
+                'data-note-number': String(number),
+                class: 'work-document-note'
+            }),
+            0
+        ];
+    }
+});
+function insertDocumentNoteCommand({ dispatch, editor, state, tr }, kind) {
+    const section = activeDocumentSectionFromState(state);
+    const referenceType = editor.schema.nodes.documentNoteReference;
+    const noteType = editor.schema.nodes.documentNote;
+    const paragraphType = editor.schema.nodes.paragraph;
+    if (!section || !referenceType || !noteType || !paragraphType || work_document_note_nodes_selectionInsideNode(state, 'documentNote')) return false;
+    if (!dispatch) return true;
+    const number = nextNoteNumber(state, kind);
+    const id = createWorkId(kind);
+    const attributes = {
+        id,
+        kind,
+        number
+    };
+    tr.replaceSelectionWith(referenceType.create(attributes), false);
+    const updatedSection = tr.doc.nodeAt(section.position);
+    if (!updatedSection || 'documentSection' !== updatedSection.type.name) return false;
+    const insertPosition = section.position + updatedSection.nodeSize - 1;
+    tr.insert(insertPosition, noteType.create(attributes, paragraphType.create()));
+    tr.setSelection(TextSelection.near(tr.doc.resolve(insertPosition + 2)));
+    tr.scrollIntoView();
+    return true;
+}
+function nextNoteNumber(state, kind) {
+    const ids = new Set();
+    state.doc.descendants((node)=>{
+        if ('documentNoteReference' !== node.type.name || node.attrs.kind !== kind) return;
+        const id = 'string' == typeof node.attrs.id ? node.attrs.id : '';
+        if (id) ids.add(documentNoteKey(kind, id));
+    });
+    return ids.size + 1;
+}
+function work_document_note_nodes_selectionInsideNode(state, nodeName) {
+    for(let depth = state.selection.$from.depth; depth > 0; depth -= 1)if (state.selection.$from.node(depth).type.name === nodeName) return true;
+    return false;
+}
+function work_document_note_nodes_hiddenAttribute(defaultValue) {
+    return {
+        default: defaultValue,
+        rendered: false
+    };
+}
+function work_document_note_nodes_positiveInteger(value) {
+    const number = Number(value);
+    return Number.isSafeInteger(number) && number > 0 ? number : 1;
+}
+const DocumentPageBreak = Node.create({
+    name: 'pageBreak',
+    group: 'block',
+    atom: true,
+    selectable: true,
+    parseHTML () {
+        return [
+            {
+                tag: '[data-page-break]'
+            }
+        ];
+    },
+    renderHTML ({ HTMLAttributes }) {
+        return [
+            'div',
+            mergeAttributes(HTMLAttributes, {
+                'data-page-break': 'true',
+                class: 'work-page-break',
+                role: 'separator',
+                'aria-label': '分页符'
+            })
+        ];
+    },
+    addKeyboardShortcuts () {
+        return {
+            'Mod-Enter': ()=>this.editor.chain().insertContent({
+                    type: this.name
+                }).run()
+        };
+    }
+});
+const DocumentSection = Node.create({
+    name: 'documentSection',
+    group: 'block',
+    content: 'block+',
+    defining: true,
+    isolating: true,
+    addAttributes () {
+        return {
+            id: work_document_section_node_hiddenAttribute(''),
+            pageSize: work_document_section_node_hiddenAttribute('a4'),
+            orientation: work_document_section_node_hiddenAttribute('portrait'),
+            marginTop: work_document_section_node_hiddenAttribute(25),
+            marginRight: work_document_section_node_hiddenAttribute(23),
+            marginBottom: work_document_section_node_hiddenAttribute(25),
+            marginLeft: work_document_section_node_hiddenAttribute(23),
+            columnCount: work_document_section_node_hiddenAttribute(1),
+            columnSpacing: work_document_section_node_hiddenAttribute(12),
+            columnSeparator: work_document_section_node_hiddenAttribute(false),
+            columnLayout: work_document_section_node_hiddenAttribute(''),
+            breakAfter: work_document_section_node_hiddenAttribute('nextPage'),
+            headerText: work_document_section_node_hiddenAttribute(''),
+            footerText: work_document_section_node_hiddenAttribute(''),
+            showPageNumbers: work_document_section_node_hiddenAttribute(false),
+            pageNumberStart: work_document_section_node_hiddenAttribute(null),
+            pageChrome: work_document_section_node_hiddenAttribute('')
+        };
+    },
+    addCommands () {
+        return {
+            insertDocumentSection: (breakAfter = 'nextPage')=>({ dispatch, editor, state, tr })=>{
+                    const section = activeDocumentSection(editor);
+                    if (!section || !editor.schema.nodes.documentSection || !editor.schema.nodes.paragraph) return false;
+                    return dispatch ? insertDocumentSection(editor, breakAfter, {
+                        state,
+                        tr
+                    }) : true;
+                },
+            mergeDocumentSectionWithPrevious: ()=>({ dispatch, editor, state, tr })=>{
+                    const section = activeDocumentSection(editor);
+                    if (!section || 0 === section.index) return false;
+                    return dispatch ? mergeDocumentSectionWithPrevious(editor, {
+                        state,
+                        tr
+                    }) : true;
+                },
+            updateActiveDocumentSection: (layout)=>({ dispatch, editor, state, tr })=>{
+                    if (!activeDocumentSection(editor)) return false;
+                    return dispatch ? updateActiveDocumentSection(layout, {
+                        state,
+                        tr
+                    }) : true;
+                },
+            updateDocumentSection: (sectionId, layout)=>({ dispatch, editor, state, tr })=>{
+                    if (!documentSectionById(editor, sectionId)) return false;
+                    return dispatch ? updateDocumentSection(sectionId, layout, {
+                        state,
+                        tr
+                    }) : true;
+                }
+        };
+    },
+    parseHTML () {
+        return [
+            {
+                tag: 'section[data-document-section]',
+                getAttrs: (node)=>{
+                    if (!(node instanceof HTMLElement)) return false;
+                    return {
+                        id: node.dataset.sectionId ?? '',
+                        pageSize: 'letter' === node.dataset.sectionPageSize ? 'letter' : 'a4',
+                        orientation: 'landscape' === node.dataset.sectionOrientation ? 'landscape' : 'portrait',
+                        marginTop: numberAttribute(node, 'sectionMarginTop', 25),
+                        marginRight: numberAttribute(node, 'sectionMarginRight', 23),
+                        marginBottom: numberAttribute(node, 'sectionMarginBottom', 25),
+                        marginLeft: numberAttribute(node, 'sectionMarginLeft', 23),
+                        columnCount: numberAttribute(node, 'sectionColumnCount', 1),
+                        columnSpacing: numberAttribute(node, 'sectionColumnSpacing', 12),
+                        columnSeparator: 'true' === node.dataset.sectionColumnSeparator,
+                        columnLayout: node.dataset.sectionColumnLayout ?? '',
+                        breakAfter: sectionBreakAttribute(node.dataset.sectionBreakAfter),
+                        headerText: node.dataset.sectionHeaderText ?? '',
+                        footerText: node.dataset.sectionFooterText ?? '',
+                        showPageNumbers: 'true' === node.dataset.sectionShowPageNumbers,
+                        pageNumberStart: nullableNumberAttribute(node, 'sectionPageNumberStart'),
+                        pageChrome: node.dataset.sectionPageChrome ?? ''
+                    };
+                }
+            }
+        ];
+    },
+    renderHTML ({ node, HTMLAttributes }) {
+        const layout = documentSectionLayoutFromNodeAttributes(node.attrs);
+        const id = 'string' == typeof node.attrs.id && node.attrs.id ? node.attrs.id : 'document-section';
+        const columns = layout.columns;
+        const style = [
+            `--work-document-column-count:${columns.count}`,
+            `--work-document-column-gap:${columns.spacing}mm`,
+            `--work-document-column-rule:${columns.separator ? '1px solid var(--a3s-line-strong)' : 'none'}`
+        ].join(';');
+        return [
+            'section',
+            mergeAttributes(HTMLAttributes, documentSectionDomAttributes(layout, id), {
+                class: 'work-document-section',
+                style
+            }),
+            0
+        ];
+    }
+});
+function work_document_section_node_hiddenAttribute(defaultValue) {
+    return {
+        default: defaultValue,
+        rendered: false
+    };
+}
+function numberAttribute(element, name, fallback) {
+    const value = Number(element.dataset[name]);
+    return Number.isFinite(value) ? value : fallback;
+}
+function nullableNumberAttribute(element, name) {
+    const source = element.dataset[name];
+    if (!source?.trim()) return null;
+    const value = Number(source);
+    return Number.isFinite(value) ? value : null;
+}
+function sectionBreakAttribute(value) {
+    if ('continuous' === value || 'evenPage' === value || 'oddPage' === value || 'nextColumn' === value) return value;
+    return 'nextPage';
+}
+const DOCUMENT_TAB_SELECTOR = 'span[data-document-tab]';
+const DOCUMENT_TAB_BLOCK_SELECTOR = 'p, h1, h2, h3, h4, h5, h6';
+const MINIMUM_DOCUMENT_TAB_WIDTH_PX = 1;
+const DocumentTab = Node.create({
+    name: 'documentTab',
+    group: 'inline',
+    inline: true,
+    atom: true,
+    selectable: false,
+    parseHTML () {
+        return [
+            {
+                tag: DOCUMENT_TAB_SELECTOR
+            }
+        ];
+    },
+    renderHTML ({ HTMLAttributes }) {
+        return [
+            'span',
+            mergeAttributes(HTMLAttributes, {
+                'data-document-tab': 'true',
+                class: 'work-document-tab',
+                role: 'separator',
+                'aria-label': '制表符'
+            })
+        ];
+    },
+    addNodeView () {
+        return ()=>{
+            const dom = document.createElement('span');
+            dom.className = 'work-document-tab';
+            dom.dataset.documentTab = 'true';
+            dom.setAttribute('role', 'separator');
+            dom.setAttribute('aria-label', '制表符');
+            dom.contentEditable = 'false';
+            return {
+                dom,
+                ignoreMutation: ()=>true
+            };
+        };
+    },
+    addKeyboardShortcuts () {
+        return {
+            Tab: ()=>{
+                const position = this.editor.state.selection.$from;
+                if (selectionIsInsideTableCell(position) || selectionIsInsideListItem(position)) return false;
+                return this.editor.chain().focus().insertContent({
+                    type: this.name
+                }).run();
+            }
+        };
+    },
+    addProseMirrorPlugins () {
+        return [
+            new Plugin({
+                view: (view)=>createDocumentTabLayoutView(view)
+            })
+        ];
+    }
+});
+function layoutDocumentTabs(root) {
+    const tabs = Array.from(root.querySelectorAll(DOCUMENT_TAB_SELECTOR));
+    for (const tab of tabs)tab.style.width = '0px';
+    for (const tab of tabs){
+        const block = tab.closest(DOCUMENT_TAB_BLOCK_SELECTOR);
+        if (!block || !root.contains(block)) continue;
+        const tabStops = normalizeDocumentTabStops(block.dataset.officeTabStops ?? '');
+        const blockRectangle = block.getBoundingClientRect();
+        const tabRectangle = tab.getBoundingClientRect();
+        const layoutScale = documentElementLayoutScale(block, blockRectangle);
+        const leftIndent = paragraphLeftIndent(block);
+        const currentPosition = (tabRectangle.left - blockRectangle.left) / layoutScale + leftIndent;
+        const stop = nextDocumentTabStop(tabStops, currentPosition);
+        const offset = documentTabAlignmentOffset(tab, block, stop.alignment, layoutScale);
+        const width = Math.max(MINIMUM_DOCUMENT_TAB_WIDTH_PX, stop.position - currentPosition - offset);
+        tab.style.width = `${roundLayoutValue(width)}px`;
+        tab.dataset.documentTabAlignment = stop.alignment;
+        tab.dataset.documentTabLeader = stop.leader;
+    }
+}
+function nextDocumentTabStop(tabStops, currentPosition) {
+    const current = Math.max(0, currentPosition);
+    const custom = normalizeDocumentTabStops(tabStops).find((stop)=>stop.position > current + 0.5);
+    const defaultPosition = (Math.floor(current / 48) + 1) * 48;
+    if (custom && custom.position <= defaultPosition + 0.5) return custom;
+    return {
+        position: defaultPosition,
+        alignment: 'left',
+        leader: 'none'
+    };
+}
+function createDocumentTabLayoutView(view) {
+    let frame = null;
+    const schedule = ()=>{
+        if (null !== frame) cancelAnimationFrame(frame);
+        frame = requestAnimationFrame(()=>{
+            frame = null;
+            if (view.dom.isConnected) layoutDocumentTabs(view.dom);
+        });
+    };
+    const resizeObserver = "u" < typeof ResizeObserver ? null : new ResizeObserver(()=>schedule());
+    resizeObserver?.observe(view.dom);
+    window.addEventListener('resize', schedule);
+    document.fonts?.ready.then(schedule);
+    schedule();
+    return {
+        update: schedule,
+        destroy: ()=>{
+            if (null !== frame) cancelAnimationFrame(frame);
+            resizeObserver?.disconnect();
+            window.removeEventListener('resize', schedule);
+        }
+    };
+}
+function selectionIsInsideTableCell(position) {
+    for(let depth = position.depth; depth > 0; depth -= 1){
+        const name = position.node(depth).type.name;
+        if ('tableCell' === name || 'tableHeader' === name) return true;
+    }
+    return false;
+}
+function selectionIsInsideListItem(position) {
+    for(let depth = position.depth; depth > 0; depth -= 1)if ('listItem' === position.node(depth).type.name) return true;
+    return false;
+}
+function paragraphLeftIndent(block) {
+    const level = Number(block.dataset.officeIndentLevel);
+    if (Number.isFinite(level) && level > 0) return 24 * level;
+    const pixels = Number.parseFloat(block.style.marginLeft);
+    return Number.isFinite(pixels) ? Math.max(0, pixels) : 0;
+}
+function documentTabAlignmentOffset(tab, block, alignment, layoutScale) {
+    if ('left' === alignment) return 0;
+    const width = followingSegmentWidth(tab, block, 'decimal' === alignment) / layoutScale;
+    return 'center' === alignment ? width / 2 : width;
+}
+function documentElementLayoutScale(element, rectangle) {
+    const layoutWidth = element.offsetWidth;
+    if (layoutWidth <= 0 || rectangle.width <= 0) return 1;
+    const scale = rectangle.width / layoutWidth;
+    return Number.isFinite(scale) && scale > 0 ? scale : 1;
+}
+function followingSegmentWidth(tab, block, stopAtDecimal) {
+    const document1 = block.ownerDocument;
+    const range = document1.createRange();
+    range.setStartAfter(tab);
+    const nextTab = nextTabElement(tab, block);
+    const decimal = stopAtDecimal ? firstDecimalPosition(tab, block, nextTab) : null;
+    if (decimal) range.setEnd(decimal.node, decimal.offset);
+    else if (nextTab) range.setEndBefore(nextTab);
+    else range.setEnd(block, block.childNodes.length);
+    const rects = 'function' == typeof range.getClientRects ? Array.from(range.getClientRects()) : [];
+    const first = rects[0];
+    if (first && Number.isFinite(first.width)) return Math.max(0, first.width);
+    if ('function' != typeof range.getBoundingClientRect) return 0;
+    const rectangle = range.getBoundingClientRect();
+    return Number.isFinite(rectangle.width) ? Math.max(0, rectangle.width) : 0;
+}
+function nextTabElement(current, block) {
+    const tabs = Array.from(block.querySelectorAll(DOCUMENT_TAB_SELECTOR));
+    const index = tabs.indexOf(current);
+    return index >= 0 ? tabs[index + 1] ?? null : null;
+}
+function firstDecimalPosition(current, block, nextTab) {
+    const walker = block.ownerDocument.createTreeWalker(block, NodeFilter.SHOW_TEXT);
+    let afterCurrent = false;
+    while(walker.nextNode()){
+        const node = walker.currentNode;
+        if (!afterCurrent) {
+            afterCurrent = Boolean(current.compareDocumentPosition(node) & globalThis.Node.DOCUMENT_POSITION_FOLLOWING);
+            if (!afterCurrent) continue;
+        }
+        if (nextTab && !(nextTab.compareDocumentPosition(node) & globalThis.Node.DOCUMENT_POSITION_PRECEDING)) break;
+        const offset = node.data.search(/[.,，。]/);
+        if (offset >= 0) return {
+            node,
+            offset
+        };
+    }
+    return null;
+}
+function roundLayoutValue(value) {
+    return Math.round(100 * value) / 100;
+}
+function documentTabLeaderLabel(leader) {
+    if ('dot' === leader) return '点线前导符';
+    if ('hyphen' === leader) return '短横线前导符';
+    if ('underscore' === leader) return '下划线前导符';
+    if ('middleDot' === leader) return '居中点前导符';
+    return '无前导符';
+}
+const DocumentTableCommands = Extension.create({
+    name: 'documentTableCommands',
+    addCommands () {
+        return {
+            insertDocumentTable: (dimensions, options = {})=>(props)=>insertDocumentTable(props, dimensions, options)
+        };
+    }
+});
+function insertDocumentTable({ chain, dispatch, editor, state }, dimensions, options) {
+    const rows = work_document_table_commands_positiveInteger(dimensions.rows);
+    const columns = work_document_table_commands_positiveInteger(dimensions.columns);
+    if (null === rows || null === columns) return false;
+    const headerRow = false !== options.headerRow;
+    const selection = state.selection;
+    if (!selection.empty) {
+        const createdTable = createTable(state.schema, rows, columns, headerRow);
+        const table = headerRow ? withRepeatingFirstRow(createdTable) : createdTable;
+        const insertionPosition = blockInsertionPosition(selection.$to, table.type);
+        if (null !== insertionPosition) {
+            const transaction = state.tr.insert(insertionPosition, table);
+            transaction.setSelection(TextSelection.near(transaction.doc.resolve(insertionPosition + 1))).scrollIntoView();
+            dispatch?.(transaction);
+            if (dispatch && false !== options.restoreFocus) editor.commands.focus();
+            return true;
+        }
+    }
+    let commandChain = chain();
+    if (false !== options.restoreFocus) commandChain = commandChain.focus();
+    if (!selection.empty) commandChain = commandChain.setTextSelection(selection.to);
+    commandChain = commandChain.insertTable({
+        rows,
+        cols: columns,
+        withHeaderRow: headerRow
+    });
+    if (headerRow) commandChain = commandChain.updateAttributes('tableRow', {
+        repeatHeader: true
+    });
+    return commandChain.run();
+}
+function work_document_table_commands_positiveInteger(value) {
+    if (!Number.isSafeInteger(value) || value < 1) return null;
+    return value;
+}
+function blockInsertionPosition(position, tableType) {
+    for(let depth = position.depth; depth > 0; depth -= 1){
+        const parentDepth = depth - 1;
+        const parent = position.node(parentDepth);
+        const index = position.indexAfter(parentDepth);
+        if (parent.canReplaceWith(index, index, tableType)) return position.after(depth);
+    }
+    return null;
+}
+function withRepeatingFirstRow(table) {
+    const firstRow = table.firstChild;
+    if (!firstRow) return table;
+    const repeatedRow = firstRow.type.create({
+        ...firstRow.attrs,
+        repeatHeader: true
+    }, firstRow.content, firstRow.marks);
+    return table.copy(table.content.replaceChild(0, repeatedRow));
+}
+function createWorkDocumentExtensions(options = {}) {
+    const changeExtension = DocumentChange.configure({
+        ...options.isTracking ? {
+            isTracking: options.isTracking
+        } : {},
+        ...options.createChange ? {
+            createChange: options.createChange
+        } : {},
+        ...options.onTrackingChange ? {
+            onTrackingChange: options.onTrackingChange
+        } : {}
+    });
+    const citationExtension = DocumentCitation.configure({
+        ...options.getContent ? {
+            getContent: options.getContent
+        } : {},
+        ...options.onContentChange ? {
+            onContentChange: options.onContentChange
+        } : {}
+    });
+    const commentExtension = DocumentComment.configure({
+        ...options.getContent ? {
+            getContent: options.getContent
+        } : {},
+        ...options.onContentChange ? {
+            onContentChange: options.onContentChange
+        } : {}
+    });
+    return [
+        starter_kit.configure({
+            link: {
+                autolink: true,
+                defaultProtocol: 'https',
+                openOnClick: false
+            },
+            underline: false,
+            bulletList: false,
+            orderedList: false,
+            trailingNode: {
+                notAfter: [
+                    'documentSection'
+                ]
+            }
+        }),
+        DocumentBulletList,
+        DocumentOrderedList,
+        DocumentListCommands,
+        DocumentSection,
+        DocumentCaption,
+        DocumentCrossReference,
+        citationExtension,
+        DocumentBibliography,
+        DocumentField,
+        commentExtension,
+        DocumentNoteReference,
+        DocumentNote,
+        extension_underline,
+        DocumentSubscript,
+        DocumentSuperscript,
+        DocumentImage.configure({
+            allowBase64: true,
+            resize: {
+                enabled: true,
+                alwaysPreserveAspectRatio: true,
+                minWidth: 60,
+                minHeight: 40
+            }
+        }),
+        TableKit.configure({
+            table: false,
+            tableCell: false,
+            tableHeader: false,
+            tableRow: false
+        }),
+        DocumentTable,
+        DocumentTableCell,
+        DocumentTableHeader,
+        DocumentTableRow,
+        DocumentTableCommands,
+        DocumentTableFormatting,
+        DocumentTableSizing,
+        TextStyle,
+        font_family,
+        font_size,
+        extension_color,
+        extension_highlight.configure({
+            multicolor: true
+        }),
+        extension_text_align.configure({
+            types: [
+                'heading',
+                'paragraph'
+            ]
+        }),
+        DocumentParagraphFormatting,
+        DocumentParagraphTabStops,
+        DocumentTab,
+        DocumentPageBreak,
+        changeExtension
+    ];
+}
+export { DocumentSubscript, DocumentSuperscript, MAX_DOCUMENT_NUMBERING_START, activeDocumentSection, canInsertDocumentComment, collectDocumentChanges, collectDocumentCommentAnchors, createWorkDocumentExtensions, documentBulletListStyle, documentCitationCount, documentCommentDraftRange, documentCommentViews, documentOrderedListState, documentSectionById, documentTabLeaderLabel, editorDocumentCaptionTargets, retainAnchoredDocumentComments };