@lvce-editor/editor-worker 19.71.0 → 19.71.2

package/dist/editorWorkerMain.js

@@ -7155,112 +7155,6 @@ const applyEdit = async (editor, changes, selectionChanges) => {
   return scheduleDocumentAndCursorsSelections(editor, changes, selectionChanges);
 };
 
-// TODO maybe use a separate worker for bulk edits and bulk edit history
-
-const sortEditsDescending = edits => {
-  return edits.toSorted((a, b) => b.offset - a.offset);
-};
-const applyEditsToText = (text, edits) => {
-  let newText = text;
-  for (const edit of sortEditsDescending(edits)) {
-    newText = newText.slice(0, edit.offset) + edit.inserted + newText.slice(edit.offset + edit.deleted);
-  }
-  return newText;
-};
-const getTextChanges = (editor, edits) => {
-  const textChanges = [];
-  for (const edit of sortEditsDescending(edits)) {
-    const startPosition = positionAt(editor, edit.offset);
-    const endPosition = positionAt(editor, edit.offset + edit.deleted);
-    const deleted = getSelectionText(editor, {
-      end: endPosition,
-      start: startPosition
-    });
-    const textChange = {
-      deleted,
-      end: endPosition,
-      inserted: [edit.inserted],
-      origin: Rename,
-      start: startPosition
-    };
-    textChanges.push(textChange);
-  }
-  return textChanges;
-};
-const groupEditsByUri = changes => {
-  const editsByUri = new Map();
-  for (const change of changes) {
-    const edits = editsByUri.get(change.uri);
-    if (edits) {
-      edits.push(...change.edits);
-    } else {
-      editsByUri.set(change.uri, [...change.edits]);
-    }
-  }
-  return editsByUri;
-};
-const getOpenEditor = (currentEditor, uri) => {
-  if (currentEditor.uri === uri) {
-    return currentEditor;
-  }
-  for (const key of getKeys$2()) {
-    const editor = get$8(Number(key))?.newState;
-    if (editor && !editor.initial && editor.uri === uri && editor.applicationId === currentEditor.applicationId) {
-      return editor;
-    }
-  }
-  return undefined;
-};
-const applyWorkspaceEdit = async (editor, changes) => {
-  object(editor);
-  array(changes);
-  let currentEditor = editor;
-  const editsByUri = groupEditsByUri(changes);
-  for (const [uri, edits] of editsByUri) {
-    const openEditor = getOpenEditor(currentEditor, uri);
-    if (openEditor) {
-      const textChanges = getTextChanges(openEditor, edits);
-      const updatedEditor = await scheduleDocumentAndCursorsSelections(openEditor, textChanges);
-      if (openEditor.uid === currentEditor.uid) {
-        currentEditor = updatedEditor;
-      }
-      continue;
-    }
-    const text = await readFile(editor.applicationId, uri);
-    const newText = applyEditsToText(text, edits);
-    await invoke$9(editor.applicationId, 'FileSystem.writeFile', uri, newText);
-  }
-  return currentEditor;
-};
-
-const isPersistentWidget = widgetId => {
-  switch (widgetId) {
-    case Find:
-      return true;
-    default:
-      return false;
-  }
-};
-
-// TODO widgets should have a persistence property:
-// 1 = close by click (e.g. completion, hover, source-actions)
-// 2 = stay open on click (e.g. find)
-const closeWidgetsMaybe = widgets => {
-  if (widgets.length === 0) {
-    return widgets;
-  }
-  return widgets.filter(widget => isPersistentWidget(widget.id));
-};
-
-const hasWidget = (widgets, id) => {
-  for (const widget of widgets) {
-    if (widget.id === id) {
-      return true;
-    }
-  }
-  return false;
-};
-
 const getFormattingEdits = async editor => {
   if (editor.largeFile) {
     return [];
@@ -7644,83 +7538,354 @@ const saveUntitledFile = async (uri, content, platform, applicationId) => {
   if (!filePath) {
     return;
   }
-  await invoke$9(applicationId, 'FileSystem.writeFile', filePath, content);
-  await invoke$9(applicationId, 'Layout.handleWorkspaceRefresh');
-  return filePath;
+  await invoke$9(applicationId, 'FileSystem.writeFile', filePath, content);
+  await invoke$9(applicationId, 'Layout.handleWorkspaceRefresh');
+  return filePath;
+};
+
+const isPermissionDeniedError = error => {
+  const errorCode = 'code' in error ? error.code : undefined;
+  return errorCode === 'EACCES' || error.message.includes('EACCES:');
+};
+const showSaveErrorDialog = async error => {
+  if (isPermissionDeniedError(error)) {
+    await invoke$j('ElectronDialog.showMessageBox', {
+      buttons: ['OK'],
+      defaultId: 0,
+      message: "You don't have permission to save changes to this file.",
+      title: 'Unable to Save File',
+      type: 'error'
+    });
+    return;
+  }
+  await invoke$j('ElectronDialog.showMessageBox', {
+    buttons: ['OK'],
+    defaultId: 0,
+    detail: error.message,
+    message: 'Saving the file failed.',
+    title: 'Failed to Save File',
+    type: 'error'
+  });
+};
+
+const save$1 = async (editor, skipFormatting = false) => {
+  try {
+    const {
+      applicationId,
+      platform,
+      uri
+    } = editor;
+    if (!isUntitledFile(uri) && (await isReadonlyFile(uri, applicationId))) {
+      return editor;
+    }
+    const newEditor = await getNewEditor(editor, skipFormatting);
+    const content = applyLineEndings(getText$1(newEditor), newEditor.endOfLine);
+    if (isUntitledFile(uri)) {
+      const pickedFilePath = await saveUntitledFile(uri, content, platform, applicationId);
+      if (pickedFilePath) {
+        if (newEditor.modified) {
+          await notifyTabModifiedStatusChange(uri, false, applicationId);
+        }
+        return {
+          ...newEditor,
+          modified: false,
+          uri: pickedFilePath
+        };
+      }
+      return newEditor;
+    }
+    await saveNormalFile(uri, content, applicationId);
+    if (newEditor.modified) {
+      await notifyTabModifiedStatusChange(uri, false, applicationId);
+    }
+    return {
+      ...newEditor,
+      modified: false
+    };
+  } catch (error) {
+    // @ts-ignore
+    const betterError = new VError(error, `Failed to save file "${editor.uri}"`);
+    await handleError$1(betterError);
+    if (editor.platform === Electron) {
+      try {
+        await showSaveErrorDialog(betterError);
+      } catch (dialogError) {
+        await handleError$1(dialogError);
+      }
+    }
+    return editor;
+  }
+};
+
+const editorDiagnosticEffect = {
+  // TODO set effects delay / diagnostic delay
+  apply(editor) {
+    return updateDiagnostics(editor);
+  },
+  isActive: (oldEditor, newEditor) => !oldEditor.initial && !newEditor.loadError && newEditor.diagnosticsEnabled && (oldEditor.lines !== newEditor.lines || oldEditor.languageId !== newEditor.languageId)
+};
+
+const cursorUndoLimit = 100;
+const selectionsEqual = (left, right) => {
+  if (left === right) {
+    return true;
+  }
+  if (left.length !== right.length) {
+    return false;
+  }
+  for (let i = 0; i < left.length; i++) {
+    if (left[i] !== right[i]) {
+      return false;
+    }
+  }
+  return true;
+};
+const saveAfterDelay = async (uid, token) => {
+  if (!get$8(uid)) {
+    consume(uid, token);
+    return;
+  }
+  let didSave = false;
+  const save = wrapCommand$1(async editor => {
+    if (!isLatest(uid, token)) {
+      return editor;
+    }
+    consume(uid, token);
+    const autoSave = await get$3('files.autoSave');
+    if (autoSave !== 'afterDelay') {
+      return editor;
+    }
+    const savedEditor = await save$1(editor);
+    didSave = savedEditor !== editor;
+    return savedEditor;
+  });
+  await save(uid);
+  if (didSave) {
+    await invoke$d('Editor.renderPending', uid);
+  }
+};
+
+// TODO wrap commands globally, not per editor
+// TODO only store editor state in editor worker, not in renderer worker also
+
+const wrapCommand$1 = (fn, preservesTypingCoalescing = false, returnState = true) => async (uid, ...args) => {
+  return enqueue(uid, async () => {
+    const oldInstance = get$8(uid);
+    if (!oldInstance) {
+      return undefined;
+    }
+    const state = oldInstance.newState;
+    const {
+      cursorUndoStack,
+      endOfLine,
+      initial,
+      insertSpaces,
+      isSelecting,
+      lines,
+      modified,
+      redoStack,
+      selections,
+      undoStack,
+      uri
+    } = state;
+    const commandResult = await fn(state, ...args);
+    let newEditor = !preservesTypingCoalescing && commandResult.canCoalesceTyping ? {
+      ...commandResult,
+      canCoalesceTyping: false
+    } : commandResult;
+    if (lines !== newEditor.lines && newEditor.cursorUndoStack?.length) {
+      newEditor = {
+        ...newEditor,
+        cursorUndoStack: []
+      };
+    } else if (selections && newEditor.selections && !isSelecting && newEditor.cursorUndoStack === cursorUndoStack && (!selectionsEqual(selections, newEditor.selections) || newEditor.isSelecting)) {
+      const previousCursorUndoStack = cursorUndoStack || [];
+      newEditor = {
+        ...newEditor,
+        cursorUndoStack: [...previousCursorUndoStack.slice(1 - cursorUndoLimit), new Uint32Array(selections)]
+      };
+    }
+    if (state === newEditor) {
+      return returnState ? newEditor : undefined;
+    }
+    const newEditorWithDerivedState = await updateDerivedState(state, newEditor);
+    set$a(uid, state, newEditorWithDerivedState);
+    await dispose$3();
+    if (editorDiagnosticEffect.isActive(state, newEditorWithDerivedState)) {
+      void editorDiagnosticEffect.apply(newEditorWithDerivedState);
+    }
+    const finalEditor = newEditorWithDerivedState;
+    await notifyEditorStatusChange(state, finalEditor);
+    if (!initial && uri === finalEditor.uri && (endOfLine !== finalEditor.endOfLine || insertSpaces !== finalEditor.insertSpaces || lines !== finalEditor.lines || modified !== finalEditor.modified || redoStack !== finalEditor.redoStack || undoStack !== finalEditor.undoStack)) {
+      for (const key of getKeys$2()) {
+        const otherUid = Number(key);
+        const instance = get$8(otherUid);
+        const editor = instance?.newState;
+        if (otherUid === uid || !instance || !editor || editor.initial || editor.uri !== finalEditor.uri || editor.applicationId !== finalEditor.applicationId) {
+          continue;
+        }
+        const synchronizedEditor = await updateDerivedState(editor, {
+          ...editor,
+          decorations: finalEditor.decorations,
+          diagnostics: finalEditor.diagnostics,
+          endOfLine: finalEditor.endOfLine,
+          incrementalEdits: emptyIncrementalEdits,
+          insertSpaces: finalEditor.insertSpaces,
+          invalidStartIndex: Math.min(editor.invalidStartIndex, finalEditor.invalidStartIndex),
+          lines: finalEditor.lines,
+          modified: finalEditor.modified,
+          redoStack: finalEditor.redoStack,
+          undoStack: finalEditor.undoStack,
+          visualDecorations: finalEditor.visualDecorations
+        });
+        set$a(otherUid, instance.oldState, synchronizedEditor);
+        if (editorDiagnosticEffect.isActive(editor, synchronizedEditor)) {
+          void editorDiagnosticEffect.apply(synchronizedEditor);
+        }
+      }
+    }
+    if (lines !== finalEditor.lines && !isUntitledFile(finalEditor.uri)) {
+      schedule(uid, token => saveAfterDelay(uid, token));
+    } else if (modified && !finalEditor.modified) {
+      dispose$4(uid);
+    }
+    return returnState ? finalEditor : undefined;
+  });
+};
+const wrapFocusCommand$1 = (fn, returnState = true) => {
+  const command = wrapCommand$1((editor, widgetRevision) => {
+    if (editor.widgetRevision !== widgetRevision && editor.focus !== FocusEditorText$1) {
+      return editor;
+    }
+    return fn(editor);
+  }, false, returnState);
+  return uid => {
+    // DOM focus events can arrive while a queued command is still opening a widget.
+    const widgetRevision = get$8(uid)?.newState.widgetRevision;
+    return command(uid, widgetRevision);
+  };
+};
+
+// Optional provider work must not hold the editing queue while another worker responds.
+const wrapDeferredCommand$1 = (fn, returnState = true) => {
+  const apply = wrapCommand$1((editor, snapshot, result) => editor === snapshot ? result : editor, false, returnState);
+  return async (uid, ...args) => {
+    const snapshot = await enqueue(uid, async () => get$8(uid)?.newState);
+    if (!snapshot) {
+      return undefined;
+    }
+    const result = await fn(snapshot, ...args);
+    return apply(uid, snapshot, result);
+  };
+};
+
+// TODO maybe use a separate worker for bulk edits and bulk edit history
+
+const sortEditsDescending = edits => {
+  return edits.toSorted((a, b) => b.offset - a.offset);
+};
+const applyEditsToText = (text, edits) => {
+  let newText = text;
+  for (const edit of sortEditsDescending(edits)) {
+    newText = newText.slice(0, edit.offset) + edit.inserted + newText.slice(edit.offset + edit.deleted);
+  }
+  return newText;
+};
+const getTextChanges = (editor, edits) => {
+  const textChanges = [];
+  for (const edit of sortEditsDescending(edits)) {
+    const startPosition = positionAt(editor, edit.offset);
+    const endPosition = positionAt(editor, edit.offset + edit.deleted);
+    const deleted = getSelectionText(editor, {
+      end: endPosition,
+      start: startPosition
+    });
+    const textChange = {
+      deleted,
+      end: endPosition,
+      inserted: [edit.inserted],
+      origin: Rename,
+      start: startPosition
+    };
+    textChanges.push(textChange);
+  }
+  return textChanges;
+};
+const groupEditsByUri = changes => {
+  const editsByUri = new Map();
+  for (const change of changes) {
+    const edits = editsByUri.get(change.uri);
+    if (edits) {
+      edits.push(...change.edits);
+    } else {
+      editsByUri.set(change.uri, [...change.edits]);
+    }
+  }
+  return editsByUri;
+};
+const getOpenEditor = (currentEditor, uri) => {
+  if (currentEditor.uri === uri) {
+    return currentEditor;
+  }
+  for (const key of getKeys$2()) {
+    const editor = get$8(Number(key))?.newState;
+    if (editor && !editor.initial && editor.uri === uri && editor.applicationId === currentEditor.applicationId) {
+      return editor;
+    }
+  }
+  return undefined;
+};
+const updateOpenEditor = wrapCommand$1(scheduleDocumentAndCursorsSelections);
+const applyWorkspaceEdit = async (editor, changes) => {
+  object(editor);
+  array(changes);
+  let currentEditor = editor;
+  const editsByUri = groupEditsByUri(changes);
+  for (const [uri, edits] of editsByUri) {
+    const openEditor = getOpenEditor(currentEditor, uri);
+    if (openEditor) {
+      const textChanges = getTextChanges(openEditor, edits);
+      if (openEditor.uid === currentEditor.uid) {
+        currentEditor = await scheduleDocumentAndCursorsSelections(openEditor, textChanges);
+      } else {
+        await updateOpenEditor(openEditor.uid, textChanges);
+        await invoke$5('Editor.renderPending', openEditor.uid);
+      }
+      continue;
+    }
+    const text = await readFile(editor.applicationId, uri);
+    const newText = applyEditsToText(text, edits);
+    await invoke$9(editor.applicationId, 'FileSystem.writeFile', uri, newText);
+  }
+  return currentEditor;
 };
 
-const isPermissionDeniedError = error => {
-  const errorCode = 'code' in error ? error.code : undefined;
-  return errorCode === 'EACCES' || error.message.includes('EACCES:');
+const isPersistentWidget = widgetId => {
+  switch (widgetId) {
+    case Find:
+      return true;
+    default:
+      return false;
+  }
 };
-const showSaveErrorDialog = async error => {
-  if (isPermissionDeniedError(error)) {
-    await invoke$j('ElectronDialog.showMessageBox', {
-      buttons: ['OK'],
-      defaultId: 0,
-      message: "You don't have permission to save changes to this file.",
-      title: 'Unable to Save File',
-      type: 'error'
-    });
-    return;
+
+// TODO widgets should have a persistence property:
+// 1 = close by click (e.g. completion, hover, source-actions)
+// 2 = stay open on click (e.g. find)
+const closeWidgetsMaybe = widgets => {
+  if (widgets.length === 0) {
+    return widgets;
   }
-  await invoke$j('ElectronDialog.showMessageBox', {
-    buttons: ['OK'],
-    defaultId: 0,
-    detail: error.message,
-    message: 'Saving the file failed.',
-    title: 'Failed to Save File',
-    type: 'error'
-  });
+  return widgets.filter(widget => isPersistentWidget(widget.id));
 };
 
-const save$1 = async (editor, skipFormatting = false) => {
-  try {
-    const {
-      applicationId,
-      platform,
-      uri
-    } = editor;
-    if (!isUntitledFile(uri) && (await isReadonlyFile(uri, applicationId))) {
-      return editor;
-    }
-    const newEditor = await getNewEditor(editor, skipFormatting);
-    const content = applyLineEndings(getText$1(newEditor), newEditor.endOfLine);
-    if (isUntitledFile(uri)) {
-      const pickedFilePath = await saveUntitledFile(uri, content, platform, applicationId);
-      if (pickedFilePath) {
-        if (newEditor.modified) {
-          await notifyTabModifiedStatusChange(uri, false, applicationId);
-        }
-        return {
-          ...newEditor,
-          modified: false,
-          uri: pickedFilePath
-        };
-      }
-      return newEditor;
-    }
-    await saveNormalFile(uri, content, applicationId);
-    if (newEditor.modified) {
-      await notifyTabModifiedStatusChange(uri, false, applicationId);
-    }
-    return {
-      ...newEditor,
-      modified: false
-    };
-  } catch (error) {
-    // @ts-ignore
-    const betterError = new VError(error, `Failed to save file "${editor.uri}"`);
-    await handleError$1(betterError);
-    if (editor.platform === Electron) {
-      try {
-        await showSaveErrorDialog(betterError);
-      } catch (dialogError) {
-        await handleError$1(dialogError);
-      }
+const hasWidget = (widgets, id) => {
+  for (const widget of widgets) {
+    if (widget.id === id) {
+      return true;
     }
-    return editor;
   }
+  return false;
 };
 
 const handleBlur$1 = async editor => {
@@ -9503,6 +9668,7 @@ const EditorCloseColorPicker = 'Editor: Close Color Picker';
 const EditorCopyLineDown = 'Editor: Copy Line Down';
 const EditorCopyLineUp = 'Editor: Copy Line Up';
 const EditorDecrementSelection = 'Editor: Decrement Selection';
+const EditorExpandSelection = 'Editor: Expand Selection';
 const EditorFormatDocumentForced = 'Editor: Format Document (forced)';
 const EditorGoToDefinition = 'Editor: Go To Definition';
 const EditorGoToTypeDefinition = 'Editor: Go To Type Definition';
@@ -9512,6 +9678,7 @@ const EditorIncrementSelection = 'Editor: Increment Selection';
 const EditorOpenColorPicker = 'Editor: Open Color Picker';
 const EditorSelectAllOccurrences = 'Editor: Select All Occurrences';
 const EditorSelectDown = 'Editor: Select Down';
+const EditorShrinkSelection = 'Editor: Shrink Selection';
 const EditorSelectInsideString = 'Editor: Select Inside String';
 const EditorSelectNextOccurrence = 'Editor: Select Next Occurrence';
 const EditorSelectUp = 'Editor: Select Up';
@@ -9675,6 +9842,12 @@ const editorToggleComment = () => {
 const editorDecrementSelection = () => {
   return i18nString(EditorDecrementSelection);
 };
+const editorExpandSelection = () => {
+  return i18nString(EditorExpandSelection);
+};
+const editorShrinkSelection = () => {
+  return i18nString(EditorShrinkSelection);
+};
 const editorSelectUp = () => {
   return i18nString(EditorSelectUp);
 };
@@ -15557,6 +15730,12 @@ const getQuickPickMenuEntries = () => {
   }, {
     id: 'Editor.cursorUndo',
     label: cursorUndo()
+  }, {
+    id: 'Editor.expandSelection',
+    label: editorExpandSelection()
+  }, {
+    id: 'Editor.shrinkSelection',
+    label: editorShrinkSelection()
   }, {
     id: 'Editor.fold',
     label: fold()
@@ -18046,168 +18225,6 @@ const revealProblem = (editor, rowIndex, columnIndex) => {
   };
 };
 
-const editorDiagnosticEffect = {
-  // TODO set effects delay / diagnostic delay
-  apply(editor) {
-    return updateDiagnostics(editor);
-  },
-  isActive: (oldEditor, newEditor) => !oldEditor.initial && !newEditor.loadError && newEditor.diagnosticsEnabled && (oldEditor.lines !== newEditor.lines || oldEditor.languageId !== newEditor.languageId)
-};
-
-const cursorUndoLimit = 100;
-const selectionsEqual = (left, right) => {
-  if (left === right) {
-    return true;
-  }
-  if (left.length !== right.length) {
-    return false;
-  }
-  for (let i = 0; i < left.length; i++) {
-    if (left[i] !== right[i]) {
-      return false;
-    }
-  }
-  return true;
-};
-const saveAfterDelay = async (uid, token) => {
-  if (!get$8(uid)) {
-    consume(uid, token);
-    return;
-  }
-  let didSave = false;
-  const save = wrapCommand$1(async editor => {
-    if (!isLatest(uid, token)) {
-      return editor;
-    }
-    consume(uid, token);
-    const autoSave = await get$3('files.autoSave');
-    if (autoSave !== 'afterDelay') {
-      return editor;
-    }
-    const savedEditor = await save$1(editor);
-    didSave = savedEditor !== editor;
-    return savedEditor;
-  });
-  await save(uid);
-  if (didSave) {
-    await invoke$d('Editor.renderPending', uid);
-  }
-};
-
-// TODO wrap commands globally, not per editor
-// TODO only store editor state in editor worker, not in renderer worker also
-
-const wrapCommand$1 = (fn, preservesTypingCoalescing = false, returnState = true) => async (uid, ...args) => {
-  return enqueue(uid, async () => {
-    const oldInstance = get$8(uid);
-    if (!oldInstance) {
-      return undefined;
-    }
-    const state = oldInstance.newState;
-    const {
-      cursorUndoStack,
-      endOfLine,
-      initial,
-      insertSpaces,
-      isSelecting,
-      lines,
-      modified,
-      redoStack,
-      selections,
-      undoStack,
-      uri
-    } = state;
-    const commandResult = await fn(state, ...args);
-    let newEditor = !preservesTypingCoalescing && commandResult.canCoalesceTyping ? {
-      ...commandResult,
-      canCoalesceTyping: false
-    } : commandResult;
-    if (lines !== newEditor.lines && newEditor.cursorUndoStack?.length) {
-      newEditor = {
-        ...newEditor,
-        cursorUndoStack: []
-      };
-    } else if (selections && newEditor.selections && !isSelecting && newEditor.cursorUndoStack === cursorUndoStack && (!selectionsEqual(selections, newEditor.selections) || newEditor.isSelecting)) {
-      const previousCursorUndoStack = cursorUndoStack || [];
-      newEditor = {
-        ...newEditor,
-        cursorUndoStack: [...previousCursorUndoStack.slice(1 - cursorUndoLimit), new Uint32Array(selections)]
-      };
-    }
-    if (state === newEditor) {
-      return returnState ? newEditor : undefined;
-    }
-    const newEditorWithDerivedState = await updateDerivedState(state, newEditor);
-    set$a(uid, state, newEditorWithDerivedState);
-    await dispose$3();
-    if (editorDiagnosticEffect.isActive(state, newEditorWithDerivedState)) {
-      void editorDiagnosticEffect.apply(newEditorWithDerivedState);
-    }
-    const finalEditor = newEditorWithDerivedState;
-    await notifyEditorStatusChange(state, finalEditor);
-    if (!initial && uri === finalEditor.uri && (endOfLine !== finalEditor.endOfLine || insertSpaces !== finalEditor.insertSpaces || lines !== finalEditor.lines || modified !== finalEditor.modified || redoStack !== finalEditor.redoStack || undoStack !== finalEditor.undoStack)) {
-      for (const key of getKeys$2()) {
-        const otherUid = Number(key);
-        const instance = get$8(otherUid);
-        const editor = instance?.newState;
-        if (otherUid === uid || !instance || !editor || editor.initial || editor.uri !== finalEditor.uri || editor.applicationId !== finalEditor.applicationId) {
-          continue;
-        }
-        const synchronizedEditor = await updateDerivedState(editor, {
-          ...editor,
-          decorations: finalEditor.decorations,
-          diagnostics: finalEditor.diagnostics,
-          endOfLine: finalEditor.endOfLine,
-          incrementalEdits: emptyIncrementalEdits,
-          insertSpaces: finalEditor.insertSpaces,
-          invalidStartIndex: Math.min(editor.invalidStartIndex, finalEditor.invalidStartIndex),
-          lines: finalEditor.lines,
-          modified: finalEditor.modified,
-          redoStack: finalEditor.redoStack,
-          undoStack: finalEditor.undoStack,
-          visualDecorations: finalEditor.visualDecorations
-        });
-        set$a(otherUid, instance.oldState, synchronizedEditor);
-        if (editorDiagnosticEffect.isActive(editor, synchronizedEditor)) {
-          void editorDiagnosticEffect.apply(synchronizedEditor);
-        }
-      }
-    }
-    if (lines !== finalEditor.lines && !isUntitledFile(finalEditor.uri)) {
-      schedule(uid, token => saveAfterDelay(uid, token));
-    } else if (modified && !finalEditor.modified) {
-      dispose$4(uid);
-    }
-    return returnState ? finalEditor : undefined;
-  });
-};
-const wrapFocusCommand$1 = (fn, returnState = true) => {
-  const command = wrapCommand$1((editor, widgetRevision) => {
-    if (editor.widgetRevision !== widgetRevision && editor.focus !== FocusEditorText$1) {
-      return editor;
-    }
-    return fn(editor);
-  }, false, returnState);
-  return uid => {
-    // DOM focus events can arrive while a queued command is still opening a widget.
-    const widgetRevision = get$8(uid)?.newState.widgetRevision;
-    return command(uid, widgetRevision);
-  };
-};
-
-// Optional provider work must not hold the editing queue while another worker responds.
-const wrapDeferredCommand$1 = (fn, returnState = true) => {
-  const apply = wrapCommand$1((editor, snapshot, result) => editor === snapshot ? result : editor, false, returnState);
-  return async (uid, ...args) => {
-    const snapshot = await enqueue(uid, async () => get$8(uid)?.newState);
-    if (!snapshot) {
-      return undefined;
-    }
-    const result = await fn(snapshot, ...args);
-    return apply(uid, snapshot, result);
-  };
-};
-
 const save = async (uid, skipFormatting = false) => {
   let savedFrom;
   const saveContent = wrapCommand$1(async editor => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/editor-worker",
-  "version": "19.71.0",
+  "version": "19.71.2",
   "repository": {
     "type": "git",
     "url": "git@github.com:lvce-editor/editor-worker.git"