@a3s-lab/office 0.37.0 → 0.37.2

package/dist/0~3557.js

@@ -1,4 +1,5 @@
 import { useEffect, useLayoutEffect, useMemo, useRef } from "react";
+import { isOfficeCompositionKeyboardEvent } from "./0~3635.js";
 import { matchesOfficeEditorKeyboardShortcut } from "./0~8136.js";
 const DEFAULT_EXTENSION_PRIORITY = 100;
 function createOfficeEditorExtension(config) {
@@ -97,7 +98,7 @@ function createOfficeEditorRuntime(initialContext, extensions, options = {}) {
         storage: Object.freeze(storage),
         can: ()=>canApi,
         handleKeyDown: (event)=>{
-            if (event.defaultPrevented) return false;
+            if (event.defaultPrevented || isOfficeCompositionKeyboardEvent(event)) return false;
             for (const instance of instances)for (const shortcut of instance.keyboardShortcuts)if (matchesOfficeEditorKeyboardShortcut(event, shortcut.shortcut) && shortcut.handler(readContext(), commandApi, canApi, event)) {
                 event.preventDefault();
                 return true;

package/dist/0~3635.js

@@ -314,10 +314,13 @@ function swatchForeground(color) {
 }
 const MODAL_DIALOG_SELECTOR = '[role="dialog"][aria-modal="true"]';
 const OFFICE_SHORTCUT_IGNORE_SELECTOR = '[data-office-shortcuts="ignore"]';
+function isOfficeCompositionKeyboardEvent(event) {
+    return event.isComposing || 'Process' === event.key || 229 === event.keyCode;
+}
 function isOfficeShortcutBlocked(target) {
     if ("u" < typeof document) return false;
     if (target instanceof Element && (target.closest(MODAL_DIALOG_SELECTOR) || target.closest(OFFICE_SHORTCUT_IGNORE_SELECTOR))) return true;
     if (document.activeElement instanceof Element && (document.activeElement.closest(MODAL_DIALOG_SELECTOR) || document.activeElement.closest(OFFICE_SHORTCUT_IGNORE_SELECTOR))) return true;
     return null !== document.querySelector(MODAL_DIALOG_SELECTOR);
 }
-export { OfficeColorPicker, isOfficeShortcutBlocked };
+export { OfficeColorPicker, isOfficeCompositionKeyboardEvent, isOfficeShortcutBlocked };

package/dist/0~9073.js

@@ -1,7 +1,7 @@
 import { Fragment as jsx_runtime_Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { Fragment, useCallback, useEffect, useId, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { createPortal } from "react-dom";
-import { ArrowUpRight, Check, ChevronDown, ChevronLeft, ChevronRight, ChevronUp, Eye, Minus, Plus } from "lucide-react";
+import { ArrowUpRight, Check, ChevronDown, ChevronLeft, ChevronRight, ChevronUp, Eye, File, Minus, Plus } from "lucide-react";
 import { WorkOfficeCollaborationParticipants, moveOfficeMenuFocus, Popover, matchesAriaKeyShortcuts, officeOverlayPortalRoot } from "./0~8136.js";
 const CONTEXT_MENU_MARGIN = 8;
 const CONTEXT_MENU_TAB_STOP_SELECTOR = 'a[href]:not([tabindex="-1"]), button:not(:disabled):not([tabindex="-1"]), input:not(:disabled):not([type="hidden"]):not([tabindex="-1"]), select:not(:disabled):not([tabindex="-1"]), textarea:not(:disabled):not([tabindex="-1"]), [contenteditable="true"]:not([tabindex="-1"]), [tabindex]:not([tabindex="-1"])';
@@ -155,8 +155,8 @@ function WorkspaceContextMenu({ label, className = '', x, y, items, onClose, onR
             if (shortcutItem) {
                 event.preventDefault();
                 event.stopPropagation();
-                dismissAndRestoreFocus();
                 shortcutItem.onSelect();
+                dismissAndRestoreFocus();
             } else if ('Escape' === event.key) {
                 event.preventDefault();
                 event.stopPropagation();
@@ -193,9 +193,9 @@ function WorkspaceContextMenu({ label, className = '', x, y, items, onClose, onR
                         "aria-label": item.label,
                         "aria-keyshortcuts": item.ariaKeyShortcut,
                         onClick: ()=>{
+                            item.onSelect();
                             onClose();
                             restoreContextFocus();
-                            item.onSelect();
                         },
                         children: [
                             item.icon,
@@ -1071,6 +1071,8 @@ function WorkOfficeFileMenu({ actions }) {
                                 type: "button",
                                 role: "menuitem",
                                 tabIndex: -1,
+                                className: action.danger ? 'danger' : void 0,
+                                "data-danger": action.danger ? 'true' : void 0,
                                 disabled: action.disabled,
                                 onClick: ()=>{
                                     close();
@@ -1080,9 +1082,12 @@ function WorkOfficeFileMenu({ actions }) {
                                     /*#__PURE__*/ jsx("span", {
                                         className: "work-office-file-action-icon",
                                         "aria-hidden": "true",
-                                        children: action.icon
+                                        children: action.icon ?? /*#__PURE__*/ jsx(File, {
+                                            size: 16
+                                        })
                                     }),
                                     /*#__PURE__*/ jsx("span", {
+                                        className: "work-office-file-action-label",
                                         children: action.label
                                     }),
                                     action.shortcut && /*#__PURE__*/ jsx("kbd", {

package/dist/0~controlled-editor-composition.js

@@ -0,0 +1,54 @@
+const COMPOSITION_SETTLE_RETRY_MS = 20;
+const MAX_COMPOSITION_SETTLE_RETRIES = 4;
+class ControlledEditorComposition {
+    active = false;
+    generation = 0;
+    settling = false;
+    timer = null;
+    start() {
+        this.generation += 1;
+        this.cancelTimer();
+        this.active = true;
+        this.settling = false;
+    }
+    end(editor, onSettled) {
+        const generation = ++this.generation;
+        this.cancelTimer();
+        this.active = false;
+        this.settling = true;
+        this.scheduleSettlement(editor, onSettled, generation, 0);
+    }
+    isBlocking(editor) {
+        return this.active || this.settling || Boolean(editor && !editor.isDestroyed && editor.view.composing);
+    }
+    destroy() {
+        this.generation += 1;
+        this.cancelTimer();
+        this.active = false;
+        this.settling = false;
+    }
+    scheduleSettlement(editor, onSettled, generation, retry) {
+        const delay = 0 === retry ? 0 : COMPOSITION_SETTLE_RETRY_MS;
+        this.timer = setTimeout(()=>{
+            this.timer = null;
+            if (generation !== this.generation) return;
+            if (editor.isDestroyed) {
+                this.settling = false;
+                return;
+            }
+            if (editor.view.composing) {
+                if (retry < MAX_COMPOSITION_SETTLE_RETRIES) this.scheduleSettlement(editor, onSettled, generation, retry + 1);
+                else this.settling = false;
+                return;
+            }
+            this.settling = false;
+            onSettled(editor);
+        }, delay);
+    }
+    cancelTimer() {
+        if (null === this.timer) return;
+        clearTimeout(this.timer);
+        this.timer = null;
+    }
+}
+export { ControlledEditorComposition };

package/dist/0~document-editor.js

@@ -28,6 +28,7 @@ import { mergeOfficeTiptapExtensions, documentHasRefreshableFields, documentCurr
 import { WorkEditorLoadingState, documentLayoutFontKey, useOfficeCollaborationLocationNavigator, OFFICE_DOCUMENT_LAYOUT_HEBREW_FONT_ID, useOfficeEditorInitialFocus, OFFICE_DOCUMENT_LAYOUT_FONT_ID, OFFICE_DOCUMENT_LAYOUT_ARABIC_FONT_ID, OFFICE_DOCUMENT_LAYOUT_LATIN_FONT_ID } from "./432.js";
 import { useOfficeDraft, InlineNotice } from "./0~345.js";
 import { showToast } from "./6489.js";
+import { ControlledEditorComposition } from "./0~controlled-editor-composition.js";
 import { documentPageColor, normalizeDocumentPageColor } from "./0~work-document-page-color.js";
 var document_editor_namespaceObject = {};
 __webpack_require__.r(document_editor_namespaceObject);
@@ -19336,13 +19337,13 @@ function work_document_review_conflicts_changeKey(change) {
 function documentReviewConflictKey(conflict) {
     return 'comment' === conflict.kind ? `comment:${conflict.id}` : `change:${conflict.id}`;
 }
-function useDocumentReviewConflicts({ activeConflictsRef, appliedSourceKeyRef, artifactId, content, editor, editorInput, normalizedContent, onReviewConflict, publishedDocumentRef, reconcileControlledUpdates = true }) {
+function useDocumentReviewConflicts({ activeConflictsRef, appliedSourceKeyRef, artifactId, content, controlledUpdateRevision = 0, deferControlledUpdates = false, editor, editorInput, normalizedContent, onReviewConflict, publishedDocumentRef, reconcileControlledUpdates = true }) {
     const appliedArtifactIdRef = useRef(artifactId);
     const onReviewConflictRef = useRef(onReviewConflict);
     const [visibleConflicts, setVisibleConflicts] = useState([]);
     onReviewConflictRef.current = onReviewConflict;
     useEffect(()=>{
-        if (!editor || !reconcileControlledUpdates) return;
+        if (!editor || !reconcileControlledUpdates || deferControlledUpdates) return;
         const artifactChanged = appliedArtifactIdRef.current !== artifactId;
         const sourceChanged = appliedSourceKeyRef.current !== editorInput.sourceKey;
         appliedArtifactIdRef.current = artifactId;
@@ -19390,6 +19391,8 @@ function useDocumentReviewConflicts({ activeConflictsRef, appliedSourceKeyRef, a
         appliedSourceKeyRef,
         artifactId,
         content,
+        controlledUpdateRevision,
+        deferControlledUpdates,
         editor,
         editorInput,
         normalizedContent,
@@ -19525,6 +19528,11 @@ function DocumentEditorSurface({ artifactId, autoFocus = true, collaboration, co
     const editorBeforeCreateAtRef = useRef(null);
     const editorDetachedMountAtRef = useRef(null);
     const onChangeRef = useRef(onChange);
+    const editorRef = useRef(null);
+    const compositionRef = useRef(null);
+    compositionRef.current ??= new ControlledEditorComposition();
+    const composition = compositionRef.current;
+    const settleCompositionRef = useRef(()=>void 0);
     const trackChangesRef = useRef(suggestionOnly || Boolean(effectiveContent.trackChanges));
     const collaborationBindingRef = useRef(collaborationBinding);
     const validatedModel = useMemo(()=>documentModelForContent(effectiveContent), [
@@ -19563,6 +19571,7 @@ function DocumentEditorSurface({ artifactId, autoFocus = true, collaboration, co
     const [zoom, setZoom] = useState(90);
     const [selectionMenu, setSelectionMenu] = useState(null);
     const [selectionVersion, setSelectionVersion] = useState(0);
+    const [compositionRevision, setCompositionRevision] = useState(0);
     const [statisticsOpen, setStatisticsOpen] = useState(false);
     const loadedLayoutFontIds = useDocumentLayoutFonts(layoutFonts);
     if (!collaboration) contentRef.current = content;
@@ -19632,9 +19641,21 @@ function DocumentEditorSurface({ artifactId, autoFocus = true, collaboration, co
                 'aria-readonly': commentOnly ? 'true' : 'false',
                 role: 'textbox',
                 spellcheck: 'true'
+            },
+            handleDOMEvents: {
+                compositionstart: ()=>{
+                    composition.start();
+                    return false;
+                },
+                compositionend: ()=>{
+                    const current = editorRef.current;
+                    if (current) composition.end(current, (settled)=>settleCompositionRef.current(settled));
+                    return false;
+                }
             }
         }), [
-        commentOnly
+        commentOnly,
+        composition
     ]);
     const publishDocumentUpdate = useCallback((current, previousDocument)=>{
         if (current.isDestroyed || previousDocument.eq(current.state.doc)) return;
@@ -19680,8 +19701,9 @@ function DocumentEditorSurface({ artifactId, autoFocus = true, collaboration, co
         }
         const flush = ()=>{
             const queued = pendingLazyPublicationRef.current;
+            if (!queued || composition.isBlocking(queued.editor)) return;
             pendingLazyPublicationRef.current = null;
-            if (queued) publishDocumentUpdate(queued.editor, queued.before);
+            publishDocumentUpdate(queued.editor, queued.before);
         };
         pendingLazyPublicationRef.current = {
             before: previousDocument,
@@ -19689,15 +19711,39 @@ function DocumentEditorSurface({ artifactId, autoFocus = true, collaboration, co
             editor: current
         };
     }, [
+        composition,
         publishDocumentUpdate
     ]);
+    const publishDocumentSnapshot = useCallback((current, previousDocument, immediate = false)=>{
+        if (previousDocument.eq(current.state.doc)) return;
+        const lazyProjection = documentLazyHtmlProjection(contentRef.current.model);
+        if (lazyProjection) transferLazyDocumentTextStatistics(previousDocument, current.state.doc);
+        publishedDocumentRef.current = current.state.doc;
+        if (lazyProjection && !immediate) queueLazyDocumentPublication(current, previousDocument);
+        else publishDocumentUpdate(current, previousDocument);
+    }, [
+        publishDocumentUpdate,
+        queueLazyDocumentPublication
+    ]);
+    settleCompositionRef.current = (current)=>{
+        const pending = pendingLazyPublicationRef.current;
+        if (pending) {
+            pending.cancel();
+            pendingLazyPublicationRef.current = null;
+        }
+        const previousDocument = pending?.before ?? publishedDocumentRef.current;
+        if (previousDocument) publishDocumentSnapshot(current, previousDocument, true);
+        else publishedDocumentRef.current = current.state.doc;
+        setCompositionRevision((value)=>value + 1);
+    };
     useEffect(()=>()=>{
             const pending = pendingLazyPublicationRef.current;
             pendingLazyPublicationRef.current = null;
             if (!pending) return;
             pending.cancel();
-            publishDocumentUpdate(pending.editor, pending.before);
+            if (!composition.isBlocking(pending.editor)) publishDocumentUpdate(pending.editor, pending.before);
         }, [
+        composition,
         publishDocumentUpdate
     ]);
     const editor = useEditor({
@@ -19718,6 +19764,7 @@ function DocumentEditorSurface({ artifactId, autoFocus = true, collaboration, co
             if (null !== beforeCreateAt) recordDocumentEditorMeasure('a3s-office.document.editor-state-view', beforeCreateAt, mountedAt);
         },
         onCreate: ({ editor: current })=>{
+            editorRef.current = current;
             publishedDocumentRef.current = current.state.doc;
             const mountedAt = documentEditorNow();
             const detachedMountAt = editorDetachedMountAtRef.current;
@@ -19728,6 +19775,10 @@ function DocumentEditorSurface({ artifactId, autoFocus = true, collaboration, co
                 windowed: Boolean(editorInput.model && documentModelUsesWindowing(editorInput.model.root))
             });
         },
+        onDestroy: ()=>{
+            editorRef.current = null;
+            composition.destroy();
+        },
         onTransaction: ({ appendedTransactions, editor: current, transaction })=>{
             if (documentTransactionsOnlyHydrateChunks([
                 transaction,
@@ -19735,6 +19786,7 @@ function DocumentEditorSurface({ artifactId, autoFocus = true, collaboration, co
             ])) publishedDocumentRef.current = current.state.doc;
         },
         onUpdate: ({ appendedTransactions, editor: current, transaction })=>{
+            if (composition.isBlocking(current)) return;
             if (!shouldPublishDocumentUpdate(transaction, appendedTransactions ?? [])) {
                 publishedDocumentRef.current = current.state.doc;
                 return;
@@ -19745,11 +19797,7 @@ function DocumentEditorSurface({ artifactId, autoFocus = true, collaboration, co
             }
             const previousDocument = publishedDocumentRef.current;
             if (previousDocument.eq(current.state.doc)) return;
-            const lazyProjection = documentLazyHtmlProjection(contentRef.current.model);
-            if (lazyProjection) transferLazyDocumentTextStatistics(previousDocument, current.state.doc);
-            publishedDocumentRef.current = current.state.doc;
-            if (lazyProjection) queueLazyDocumentPublication(current, previousDocument);
-            else publishDocumentUpdate(current, previousDocument);
+            publishDocumentSnapshot(current, previousDocument);
         },
         onSelectionUpdate: ()=>setSelectionVersion((value)=>value + 1)
     });
@@ -19786,6 +19834,8 @@ function DocumentEditorSurface({ artifactId, autoFocus = true, collaboration, co
         appliedSourceKeyRef,
         artifactId,
         content: collaboration ? contentRef.current : content,
+        controlledUpdateRevision: compositionRevision,
+        deferControlledUpdates: composition.isBlocking(editor),
         editor,
         editorInput,
         normalizedContent,

package/dist/0~markdown-editor.js

@@ -15,6 +15,7 @@ import { OfficeSelect, isWorkspaceContextMenuKeyboardEvent, WorkOfficeZoomContro
 import { stepOfficeZoom, MarkdownSourcePresenceLayer, button_Button, OfficeTiptapPresenceLayer, useOfficePublishPresenceLocation, Dialog, office_text_field_OfficeTextField, useOfficeEditorWheelZoom } from "./0~8136.js";
 import { normalizeDocumentHref, DOCUMENT_LINK_VALIDATION_MESSAGE } from "./0~work-document-links.js";
 import { readOfficeMarkdownCollaboration as readWorkOfficeMarkdownCollaboration, createOfficeMarkdownCollaborationBinding as createWorkOfficeMarkdownCollaborationBinding } from "./2591.js";
+import { ControlledEditorComposition } from "./0~controlled-editor-composition.js";
 import { useOfficeEditorInitialFocus, useOfficeCollaborationLocationNavigator, WorkEditorLoadingState } from "./432.js";
 var markdown_editor_namespaceObject = {};
 __webpack_require__.r(markdown_editor_namespaceObject);
@@ -1867,6 +1868,11 @@ function MarkdownEditor({ autoFocus = true, collaboration, content, extensions:
     const initialContent = collaboration ? readWorkOfficeMarkdownCollaboration(collaboration) : content;
     const contentRef = useRef(initialContent);
     const onChangeRef = useRef(onChange);
+    const editorRef = useRef(null);
+    const compositionRef = useRef(null);
+    compositionRef.current ??= new ControlledEditorComposition();
+    const composition = compositionRef.current;
+    const publishVisualMarkdownRef = useRef(()=>void 0);
     const receivedContentRef = useRef(content);
     const appliedMarkdownRef = useRef(initialContent.markdown);
     const emittedMarkdownRef = useRef(null);
@@ -1881,6 +1887,7 @@ function MarkdownEditor({ autoFocus = true, collaboration, content, extensions:
     const [viewMode, setViewMode] = useState('split');
     const [zoom, setZoom] = useState(100);
     const [selectionVersion, setSelectionVersion] = useState(0);
+    const [compositionRevision, setCompositionRevision] = useState(0);
     const [presenceSurface, setPresenceSurface] = useState(preview ? 'visual' : 'source');
     const [sourcePresenceSelection, setSourcePresenceSelection] = useState({
         start: 0,
@@ -1910,6 +1917,20 @@ function MarkdownEditor({ autoFocus = true, collaboration, content, extensions:
                 role: 'textbox',
                 spellcheck: 'true'
             },
+            handleDOMEvents: {
+                compositionstart: ()=>{
+                    composition.start();
+                    return false;
+                },
+                compositionend: ()=>{
+                    const current = editorRef.current;
+                    if (current) composition.end(current, (settled)=>{
+                        publishVisualMarkdownRef.current(settled);
+                        setCompositionRevision((value)=>value + 1);
+                    });
+                    return false;
+                }
+            },
             handleKeyDown: (_view, event)=>{
                 if (!collaborative || readOnly || event.altKey || !(event.metaKey || event.ctrlKey)) return false;
                 const key = event.key.toLocaleLowerCase();
@@ -1926,34 +1947,51 @@ function MarkdownEditor({ autoFocus = true, collaboration, content, extensions:
             }
         }), [
         collaborative,
+        composition,
         readOnly
     ]);
+    const publishVisualMarkdown = useCallback((current)=>{
+        const markdown = current.getMarkdown();
+        if (markdown === appliedMarkdownRef.current) return;
+        cancelPreviewSync();
+        if (collaborative) {
+            appliedMarkdownRef.current = markdown;
+            collaborationBindingRef.current?.replace(markdown);
+            return;
+        }
+        const next = {
+            ...contentRef.current,
+            markdown
+        };
+        appliedMarkdownRef.current = markdown;
+        emittedMarkdownRef.current = markdown;
+        sourceMarkdownRef.current = markdown;
+        contentRef.current = next;
+        setSourceMarkdown(markdown);
+        resetSourceHistory(markdown, textareaSelection(sourceTextareaRef.current, markdown.length));
+        onChangeRef.current(next);
+    }, [
+        cancelPreviewSync,
+        collaborative,
+        resetSourceHistory
+    ]);
+    publishVisualMarkdownRef.current = publishVisualMarkdown;
     const editor = useEditor({
         extensions,
         content: initialMarkdownRef.current,
         contentType: 'markdown',
         editable: !readOnly && 'visual' === viewMode,
         editorProps,
+        onCreate: ({ editor: current })=>{
+            editorRef.current = current;
+        },
+        onDestroy: ()=>{
+            editorRef.current = null;
+            composition.destroy();
+        },
         onUpdate: ({ editor: current })=>{
-            const markdown = current.getMarkdown();
-            if (markdown === appliedMarkdownRef.current) return;
-            cancelPreviewSync();
-            if (collaborative) {
-                appliedMarkdownRef.current = markdown;
-                collaborationBindingRef.current?.replace(markdown);
-                return;
-            }
-            const next = {
-                ...contentRef.current,
-                markdown
-            };
-            appliedMarkdownRef.current = markdown;
-            emittedMarkdownRef.current = markdown;
-            sourceMarkdownRef.current = markdown;
-            contentRef.current = next;
-            setSourceMarkdown(markdown);
-            resetSourceHistory(markdown, textareaSelection(sourceTextareaRef.current, markdown.length));
-            onChangeRef.current(next);
+            if (composition.isBlocking(current)) return;
+            publishVisualMarkdownRef.current(current);
         },
         onSelectionUpdate: ()=>setSelectionVersion((value)=>value + 1)
     }, [
@@ -1961,13 +1999,14 @@ function MarkdownEditor({ autoFocus = true, collaboration, content, extensions:
     ]);
     const applyMarkdownToEditor = useCallback((markdown)=>{
         cancelPreviewSync();
-        if (!editor || editor.isDestroyed || appliedMarkdownRef.current === markdown) return;
+        if (!editor || editor.isDestroyed || composition.isBlocking(editor) || appliedMarkdownRef.current === markdown) return;
         appliedMarkdownRef.current = markdown;
         editor.commands.setWorkMarkdown(markdown, {
             emitUpdate: false
         });
     }, [
         cancelPreviewSync,
+        composition,
         editor
     ]);
     const queueMarkdownPreview = useCallback((markdown, immediate = false)=>{
@@ -2084,7 +2123,7 @@ function MarkdownEditor({ autoFocus = true, collaboration, content, extensions:
     ]);
     useEffect(()=>{
         if (collaborative) return;
-        if (!editor || receivedContentRef.current === content) return;
+        if (!editor || composition.isBlocking(editor) || receivedContentRef.current === content) return;
         receivedContentRef.current = content;
         const markdown = content.markdown;
         if (sourceMarkdownRef.current !== markdown) {
@@ -2101,6 +2140,8 @@ function MarkdownEditor({ autoFocus = true, collaboration, content, extensions:
     }, [
         content,
         collaborative,
+        composition,
+        compositionRevision,
         editor,
         readOnly,
         queueMarkdownPreview,

package/dist/0~presentation-editor.js

@@ -21,7 +21,8 @@ import { WorkspaceContextMenu, isWorkspaceContextMenuKeyboardEvent, WorkOfficeZo
 import { presentationAgentProposalTargets, SpreadsheetChartSeriesStyleEditor, applyPresentationAgentProposalChanges, normalizeOptionalOfficeNumber, SpreadsheetErrorBarEditor, useOfficeHistory, presentationNotesProposalTarget, presentationAgentSelection, SpreadsheetTrendlineEditor, presentationAgentMenuItems } from "./0~3539.js";
 import { slideTransitionDurationMilliseconds, workSlideAnimationIndex, workSlideAnimationForElement, remapWorkSlideAnimations, createWorkSlideTransition, workSlideTransitionsEqual, workSlideAnimationCues, initialWorkSlideAnimationCueIndex, normalizeWorkSlideAnimation, createWorkSlideAnimation, removeWorkSlideAnimationsForElements } from "./0~5809.js";
 import { createOfficeEditorExtension, useOfficeEditorRuntime, useOfficeEditorKeyboardShortcuts } from "./0~3557.js";
-import { isOfficeShortcutBlocked, OfficeColorPicker } from "./0~3635.js";
+import { isOfficeShortcutBlocked, OfficeColorPicker, isOfficeCompositionKeyboardEvent } from "./0~3635.js";
+import { ControlledEditorComposition } from "./0~controlled-editor-composition.js";
 import { normalizeDocumentHref, DOCUMENT_LINK_VALIDATION_MESSAGE } from "./0~work-document-links.js";
 import { showToast } from "./6489.js";
 import { scaledPresentationVisuals } from "./0~work-presentation-visual-scale.js";
@@ -4357,6 +4358,11 @@ function PresentationTextEditor({ autoFocus = false, element, onChange, onEditor
     const onEditorChangeRef = useRef(onEditorChange);
     const onExitEditingRef = useRef(onExitEditing);
     const onSelectionChangeRef = useRef(onSelectionChange);
+    const editorRef = useRef(null);
+    const compositionRef = useRef(null);
+    compositionRef.current ??= new ControlledEditorComposition();
+    const composition = compositionRef.current;
+    const [compositionRevision, setCompositionRevision] = useState(0);
     const appliedSignatureRef = useRef(presentationTextElementSignature(element));
     const initialContentRef = useRef(presentationTextElementHtml(element));
     const initialFocusTargetRef = useRef("u" > typeof document && document.activeElement instanceof HTMLElement ? document.activeElement : null);
@@ -4368,6 +4374,16 @@ function PresentationTextEditor({ autoFocus = false, element, onChange, onEditor
     const extensions = useMemo(()=>createPresentationTextEditorExtensions(element.placeholder?.prompt ?? '输入文字'), [
         element.placeholder?.prompt
     ]);
+    const publishEditorValue = (current)=>{
+        const value = presentationTextValue(current, elementRef.current);
+        const signature = presentationTextElementSignature({
+            ...elementRef.current,
+            ...value
+        });
+        if (signature === appliedSignatureRef.current) return;
+        appliedSignatureRef.current = signature;
+        onChangeRef.current(value);
+    };
     const editor = useEditor({
         extensions,
         content: initialContentRef.current,
@@ -4380,7 +4396,22 @@ function PresentationTextEditor({ autoFocus = false, element, onChange, onEditor
                 role: 'textbox',
                 spellcheck: 'true'
             },
+            handleDOMEvents: {
+                compositionstart: ()=>{
+                    composition.start();
+                    return false;
+                },
+                compositionend: ()=>{
+                    const current = editorRef.current;
+                    if (current) composition.end(current, (settled)=>{
+                        publishEditorValue(settled);
+                        setCompositionRevision((value)=>value + 1);
+                    });
+                    return false;
+                }
+            },
             handleKeyDown: (view, event)=>{
+                if (view.composing || isOfficeCompositionKeyboardEvent(event)) return false;
                 if ('Escape' !== event.key || !onExitEditingRef.current) return false;
                 const object = view.dom.closest('[data-slide-element-origin]');
                 event.preventDefault();
@@ -4390,18 +4421,17 @@ function PresentationTextEditor({ autoFocus = false, element, onChange, onEditor
             }
         },
         onCreate: ({ editor: current })=>{
+            editorRef.current = current;
             applyPresentationTextStoredMarks(current, elementRef.current);
         },
+        onDestroy: ()=>{
+            editorRef.current = null;
+            composition.destroy();
+        },
         onSelectionUpdate: ()=>onSelectionChangeRef.current?.(),
         onUpdate: ({ editor: current })=>{
-            const value = presentationTextValue(current, elementRef.current);
-            const signature = presentationTextElementSignature({
-                ...elementRef.current,
-                ...value
-            });
-            if (signature === appliedSignatureRef.current) return;
-            appliedSignatureRef.current = signature;
-            onChangeRef.current(value);
+            if (composition.isBlocking(current)) return;
+            publishEditorValue(current);
         }
     });
     useEffect(()=>{
@@ -4423,7 +4453,7 @@ function PresentationTextEditor({ autoFocus = false, element, onChange, onEditor
         editor
     ]);
     useEffect(()=>{
-        if (!editor || editor.isDestroyed) return;
+        if (!editor || editor.isDestroyed || composition.isBlocking(editor)) return;
         const signature = presentationTextElementSignature(element);
         if (signature === appliedSignatureRef.current) return;
         appliedSignatureRef.current = signature;
@@ -4432,6 +4462,8 @@ function PresentationTextEditor({ autoFocus = false, element, onChange, onEditor
         });
         applyPresentationTextStoredMarks(editor, element);
     }, [
+        composition,
+        compositionRevision,
         editor,
         element
     ]);
@@ -4956,12 +4988,22 @@ function PresentationTransitionPanel({ slideId, transition, editable, canApplyTo
             ...patch
         });
     };
-    const [advanceAfterDraft, setAdvanceAfterDraft] = useState(()=>presentationAdvanceAfterDraft(transition?.advanceAfterMs));
+    const selectedAdvanceAfterDraft = presentationAdvanceAfterDraft(transition?.advanceAfterMs);
+    const selectedAdvanceAfterDraftRef = useRef({
+        slideId,
+        value: selectedAdvanceAfterDraft
+    });
+    const [advanceAfterDraft, setAdvanceAfterDraft] = useState(selectedAdvanceAfterDraft);
     useEffect(()=>{
-        setAdvanceAfterDraft(presentationAdvanceAfterDraft(transition?.advanceAfterMs));
+        const previous = selectedAdvanceAfterDraftRef.current;
+        selectedAdvanceAfterDraftRef.current = {
+            slideId,
+            value: selectedAdvanceAfterDraft
+        };
+        setAdvanceAfterDraft((draft)=>previous.slideId !== slideId || draft === previous.value ? selectedAdvanceAfterDraft : draft);
     }, [
-        slideId,
-        transition?.advanceAfterMs
+        selectedAdvanceAfterDraft,
+        slideId
     ]);
     const commitAdvanceAfter = (value)=>{
         if (!transition || void 0 === transition.advanceAfterMs) return void setAdvanceAfterDraft('');
@@ -5176,9 +5218,18 @@ function PresentationTransitionPanel({ slideId, transition, editable, canApplyTo
                             ariaLabel: "自动换片",
                             disabled: !editable || !transition,
                             checked: transition?.advanceAfterMs !== void 0,
-                            onCheckedChange: (checked)=>update({
-                                    advanceAfterMs: checked ? 5000 : void 0
-                                }),
+                            onCheckedChange: (checked)=>{
+                                const advanceAfterMs = checked ? 5000 : void 0;
+                                const draft = presentationAdvanceAfterDraft(advanceAfterMs);
+                                selectedAdvanceAfterDraftRef.current = {
+                                    slideId,
+                                    value: draft
+                                };
+                                setAdvanceAfterDraft(draft);
+                                update({
+                                    advanceAfterMs
+                                });
+                            },
                             children: "自动换片"
                         }),
                         /*#__PURE__*/ jsxs("div", {
@@ -5306,14 +5357,25 @@ const presentationAlignmentOptions = [
 ];
 function PresentationToolbar({ selectedSlide, selectedElement, selectedUnitCount, can, textFormattingAvailable, commentsOpen, commentCount, designOpen, editingDesign, background, transition, fileActions, viewMode = 'normal', commands }) {
     const officeDialog = useOfficeDialog();
-    const [fontSizeDraft, setFontSizeDraft] = useState(()=>selectedElement ? String(selectedElement.fontSize) : '');
+    const selectedFontSize = selectedElement ? String(selectedElement.fontSize) : '';
+    const selectedFontSizeRef = useRef({
+        elementId: selectedElement?.id ?? null,
+        value: selectedFontSize
+    });
+    const [fontSizeDraft, setFontSizeDraft] = useState(selectedFontSize);
     const fontFamilyValue = presentationFontFamilyValue(selectedElement?.fontFamily);
     const selectedAnimation = workSlideAnimationForElement(selectedSlide, selectedElement?.id);
     useEffect(()=>{
-        setFontSizeDraft(selectedElement ? String(selectedElement.fontSize) : '');
+        const previous = selectedFontSizeRef.current;
+        const elementId = selectedElement?.id ?? null;
+        selectedFontSizeRef.current = {
+            elementId,
+            value: selectedFontSize
+        };
+        setFontSizeDraft((draft)=>previous.elementId !== elementId || draft === previous.value ? selectedFontSize : draft);
     }, [
-        selectedElement?.fontSize,
-        selectedElement?.id
+        selectedElement?.id,
+        selectedFontSize
     ]);
     const commitFontSize = (value)=>{
         if (!selectedElement) return;