@lvce-editor/editor-worker 18.25.0 → 18.27.0

package/dist/editorWorkerMain.js

@@ -1537,12 +1537,12 @@ const launchColorPickerWorker = async () => {
   return launchWorker(name, url);
 };
 
-let workerPromise$3;
+const state$f = {};
 const getOrCreate$3 = () => {
-  if (!workerPromise$3) {
-    workerPromise$3 = launchColorPickerWorker();
+  if (!state$f.workerPromise) {
+    state$f.workerPromise = launchColorPickerWorker();
   }
-  return workerPromise$3;
+  return state$f.workerPromise;
 };
 const invoke$9 = async (method, ...params) => {
   const worker = await getOrCreate$3();
@@ -1651,6 +1651,7 @@ const createEditor2 = (id, uri, x, y, width, height, platform, assetDir) => {
     numberOfVisibleLines: 0,
     platform,
     primarySelectionIndex: 0,
+    redoStack: [],
     rowHeight: 0,
     savedSelections: [],
     scrollBarHeight: 0,
@@ -1845,7 +1846,7 @@ const getInitialLineState = initialLineState => {
   return deepCopy(initialLineState);
 };
 
-const state$8 = {
+const state$e = {
   warned: []
 };
 const flattenTokensArray = tokens => {
@@ -1857,10 +1858,10 @@ const flattenTokensArray = tokens => {
   return flattened;
 };
 const warnDeprecatedArrayReturn = (languageId, fn) => {
-  if (state$8.warned.includes(fn)) {
+  if (state$e.warned.includes(fn)) {
     return;
   }
-  state$8.warned.push(fn);
+  state$e.warned.push(fn);
   console.warn(`tokenizers without hasArrayReturn=false are deprecated (language ${languageId})`);
 };
 const safeTokenizeLine = (languageId, tokenizeLine, line, lineStateAtStart, hasArrayReturn) => {
@@ -1921,12 +1922,14 @@ const TokenizePlainText = {
   tokenizeLine
 };
 
-let enabled$1 = false;
+const state$d = {
+  enabled: false
+};
 const setEnabled$1 = value => {
-  enabled$1 = value;
+  state$d.enabled = value;
 };
 const getEnabled$1 = () => {
-  return enabled$1;
+  return state$d.enabled;
 };
 
 const {
@@ -1934,25 +1937,25 @@ const {
   set: set$5
 } = SyntaxHighlightingWorker;
 
-const state$7 = {
+const state$c = {
   pending: Object.create(null),
   tokenizePaths: Object.create(null),
   tokenizers: Object.create(null)
 };
 const has = languageId => {
-  return Object.hasOwn(state$7.tokenizers, languageId);
+  return Object.hasOwn(state$c.tokenizers, languageId);
 };
 const set$4 = (languageId, tokenizer) => {
-  state$7.tokenizers[languageId] = tokenizer;
+  state$c.tokenizers[languageId] = tokenizer;
 };
 const get$4 = languageId => {
-  return state$7.tokenizers[languageId];
+  return state$c.tokenizers[languageId];
 };
 const setTokenizePath = (languageId, tokenizePath) => {
-  state$7.tokenizePaths[languageId] = tokenizePath;
+  state$c.tokenizePaths[languageId] = tokenizePath;
 };
 const getTokenizePath$1 = languageId => {
-  return state$7.tokenizePaths[languageId] || '';
+  return state$c.tokenizePaths[languageId] || '';
 };
 const setTokenizePaths = languages => {
   for (const language of languages) {
@@ -1962,7 +1965,7 @@ const setTokenizePaths = languages => {
   }
 };
 const isPending = languageId => {
-  return Object.hasOwn(state$7.pending, languageId);
+  return Object.hasOwn(state$c.pending, languageId);
 };
 
 const tokenMaps = Object.create(null);
@@ -2269,13 +2272,12 @@ const applyEdits = (textDocument, changes) => {
     array(inserted);
     array(deleted);
     if (startRowIndex === endRowIndex) {
+      const line = newLines[startRowIndex];
       if (inserted.length === 0) {
-        const line = newLines[startRowIndex];
         const before = line.slice(0, startColumnIndex);
         const after = line.slice(endColumnIndex);
         newLines[startRowIndex] = before + after;
       } else if (inserted.length === 1) {
-        const line = newLines[startRowIndex];
         let before = line.slice(0, startColumnIndex);
         if (startColumnIndex > line.length) {
           before += ' '.repeat(startColumnIndex - line.length);
@@ -2284,7 +2286,6 @@ const applyEdits = (textDocument, changes) => {
         const text = inserted[0];
         newLines[startRowIndex] = before + text + after;
       } else {
-        const line = newLines[startRowIndex];
         const before = line.slice(0, startColumnIndex) + inserted[0];
         const after = inserted.at(-1) + line.slice(endColumnIndex);
         spliceLargeArray(newLines, startRowIndex, deleted.length, [before, ...inserted.slice(1, -1), after]);
@@ -2292,12 +2293,11 @@ const applyEdits = (textDocument, changes) => {
         textDocument.maxLineY = Math.min(textDocument.numberOfVisibleLines, newLines.length);
       }
     } else {
+      const before = newLines[startRowIndex].slice(0, startColumnIndex) + inserted[0];
       if (inserted.length === 1) {
-        const before = newLines[startRowIndex].slice(0, startColumnIndex) + inserted[0];
         const after = endRowIndex >= newLines.length ? '' : newLines[endRowIndex].slice(endColumnIndex);
         spliceLargeArray(newLines, startRowIndex, deleted.length, [before + after]);
       } else {
-        const before = newLines[startRowIndex].slice(0, startColumnIndex) + inserted[0];
         const middle = inserted.slice(1, -1);
         const after = inserted.at(-1) + (endRowIndex >= newLines.length ? '' : newLines[endRowIndex].slice(endColumnIndex));
         spliceLargeArray(newLines, startRowIndex, deleted.length, [before, ...middle, after]);
@@ -2507,15 +2507,15 @@ const getLineInfoEmbeddedFull = (embeddedResults, tokenResults, line, decoration
       while (currentPos < tokenEnd) {
         // Find if current position is inside a decoration
         const activeDecoration = getActiveDecoration(decorationMap, currentPos);
+        let partEnd;
+        let text;
+        let className;
         if (activeDecoration) {
           // Render decorated part
-          const partEnd = Math.min(tokenEnd, activeDecoration.end);
-          const text = line.slice(currentPos, partEnd);
+          partEnd = Math.min(tokenEnd, activeDecoration.end);
+          text = line.slice(currentPos, partEnd);
           const baseTokenClass = embeddedTokenMap[tokenType] || 'Unknown';
-          const className = `Token ${baseTokenClass} ${activeDecoration.className}`;
-          const normalizedText = normalizeText(text, normalize, tabSize);
-          lineInfo.push(normalizedText, className);
-          currentPos = partEnd;
+          className = `Token ${baseTokenClass} ${activeDecoration.className}`;
         } else {
           // Find next decoration start or token end
           let nextDecorationStart = tokenEnd;
@@ -2526,13 +2526,13 @@ const getLineInfoEmbeddedFull = (embeddedResults, tokenResults, line, decoration
           }
 
           // Render non-decorated part
-          const partEnd = nextDecorationStart;
-          const text = line.slice(currentPos, partEnd);
-          const className = `Token ${embeddedTokenMap[tokenType] || 'Unknown'}`;
-          const normalizedText = normalizeText(text, normalize, tabSize);
-          lineInfo.push(normalizedText, className);
-          currentPos = partEnd;
+          partEnd = nextDecorationStart;
+          text = line.slice(currentPos, partEnd);
+          className = `Token ${embeddedTokenMap[tokenType] || 'Unknown'}`;
         }
+        const normalizedText = normalizeText(text, normalize, tabSize);
+        lineInfo.push(normalizedText, className);
+        currentPos = partEnd;
       }
     } else {
       // No decoration overlap - render token normally
@@ -2617,15 +2617,15 @@ const getLineInfoDefault = (line, tokenResults, embeddedResults, decorations, To
       while (currentPos < tokenEnd) {
         // Find if current position is inside a decoration
         const activeDecoration = getActiveDecoration(decorationMap, currentPos);
+        let partEnd;
+        let text;
+        let className;
         if (activeDecoration) {
           // Render decorated part
-          const partEnd = Math.min(tokenEnd, activeDecoration.end);
-          const text = line.slice(currentPos, partEnd);
+          partEnd = Math.min(tokenEnd, activeDecoration.end);
+          text = line.slice(currentPos, partEnd);
           const baseTokenClass = TokenMap[tokenType] || 'Unknown';
-          const className = `Token ${baseTokenClass} ${activeDecoration.className}`;
-          const normalizedText = normalizeText(text, normalize, tabSize);
-          lineInfo.push(normalizedText, className);
-          currentPos = partEnd;
+          className = `Token ${baseTokenClass} ${activeDecoration.className}`;
         } else {
           // Find next decoration start or token end
           let nextDecorationStart = tokenEnd;
@@ -2636,13 +2636,13 @@ const getLineInfoDefault = (line, tokenResults, embeddedResults, decorations, To
           }
 
           // Render non-decorated part
-          const partEnd = nextDecorationStart;
-          const text = line.slice(currentPos, partEnd);
-          const className = `Token ${TokenMap[tokenType] || 'Unknown'}`;
-          const normalizedText = normalizeText(text, normalize, tabSize);
-          lineInfo.push(normalizedText, className);
-          currentPos = partEnd;
+          partEnd = nextDecorationStart;
+          text = line.slice(currentPos, partEnd);
+          className = `Token ${TokenMap[tokenType] || 'Unknown'}`;
         }
+        const normalizedText = normalizeText(text, normalize, tabSize);
+        lineInfo.push(normalizedText, className);
+        currentPos = partEnd;
       }
     } else {
       // No decoration overlap - render token normally
@@ -2808,12 +2808,14 @@ const getNewDeltaPercent = (height, scrollBarHeight, relativeY) => {
   };
 };
 
-let enabled = false;
+const state$b = {
+  enabled: false
+};
 const setEnabled = value => {
-  enabled = value;
+  state$b.enabled = value;
 };
 const getEnabled = () => {
-  return enabled;
+  return state$b.enabled;
 };
 
 // TODO this should be in a separate scrolling module
@@ -2993,7 +2995,7 @@ const getUrlAtOffset = (editor, offset) => {
 
 const EditorChange = 1;
 
-const state$6 = Object.create(null);
+const state$a = Object.create(null);
 
 /**
  * Register a listener for a specific event type
@@ -3003,13 +3005,13 @@ const state$6 = Object.create(null);
 const registerListener$1 = (listenerType, rpcId) => {
   number(listenerType);
   number(rpcId);
-  if (!Object.hasOwn(state$6, listenerType)) {
-    state$6[listenerType] = [];
+  if (!Object.hasOwn(state$a, listenerType)) {
+    state$a[listenerType] = [];
   }
 
   // Avoid duplicate registrations
-  if (!state$6[listenerType].includes(rpcId)) {
-    state$6[listenerType].push(rpcId);
+  if (!state$a[listenerType].includes(rpcId)) {
+    state$a[listenerType].push(rpcId);
   }
 };
 
@@ -3021,10 +3023,10 @@ const registerListener$1 = (listenerType, rpcId) => {
 const unregisterListener$1 = (listenerType, rpcId) => {
   number(listenerType);
   number(rpcId);
-  if (Object.hasOwn(state$6, listenerType)) {
-    const index = state$6[listenerType].indexOf(rpcId);
+  if (Object.hasOwn(state$a, listenerType)) {
+    const index = state$a[listenerType].indexOf(rpcId);
     if (index !== -1) {
-      state$6[listenerType].splice(index, 1);
+      state$a[listenerType].splice(index, 1);
     }
   }
 };
@@ -3036,7 +3038,7 @@ const unregisterListener$1 = (listenerType, rpcId) => {
  */
 const getListeners = listenerType => {
   number(listenerType);
-  return state$6[listenerType] || [];
+  return state$a[listenerType] || [];
 };
 
 /**
@@ -3264,16 +3266,6 @@ const from = (array, getSelection) => {
   }
   return newSelections;
 };
-const push = (selections, startRowIndex, startColumnIndex, endRowIndex, endColumnIndex) => {
-  const oldLength = selections.length;
-  const newSelections = alloc(oldLength + 4);
-  newSelections.set(selections);
-  newSelections[oldLength + 1] = startRowIndex;
-  newSelections[oldLength + 2] = startColumnIndex;
-  newSelections[oldLength + 3] = endRowIndex;
-  newSelections[oldLength + 4] = endColumnIndex;
-  return newSelections;
-};
 
 // TODO maybe only accept sorted selection edits in the first place
 
@@ -3465,13 +3457,10 @@ const applyAutoClosingRangesEdit = (editor, changes) => {
     const autoStartColumnIndex = autoClosingRanges[i + 1];
     const autoEndRowIndex = autoClosingRanges[i + 2];
     const autoEndColumnIndex = autoClosingRanges[i + 3];
-    if (changeEndRowIndex === autoEndRowIndex && changeEndColumnIndex === autoEndColumnIndex) {
+    if (changeEndRowIndex === autoEndRowIndex && changeEndColumnIndex === autoEndColumnIndex || changeStartRowIndex === autoStartRowIndex && changeStartColumnIndex >= autoStartColumnIndex && changeEndRowIndex === autoEndRowIndex && changeEndColumnIndex <= autoEndColumnIndex) {
       const delta = change.inserted[0].length - change.deleted[0].length;
       newAutoClosingRanges.push(autoStartRowIndex, autoStartColumnIndex, autoEndRowIndex, autoEndColumnIndex + delta);
-    } else if (changeStartRowIndex === autoStartRowIndex && changeStartColumnIndex >= autoStartColumnIndex && changeEndRowIndex === autoEndRowIndex && changeEndColumnIndex <= autoEndColumnIndex) {
-      const delta = change.inserted[0].length - change.deleted[0].length;
-      newAutoClosingRanges.push(autoStartRowIndex, autoStartColumnIndex, autoEndRowIndex, autoEndColumnIndex + delta);
-    } else ;
+    }
   }
   if (isAutoClosingChange(change)) {
     newAutoClosingRanges.push(changeStartRowIndex, changeStartColumnIndex + 1, changeEndRowIndex, changeEndColumnIndex + 1);
@@ -3516,6 +3505,7 @@ const scheduleDocumentAndCursorsSelections = async (editor, changes, selectionCh
     invalidStartIndex,
     lines: newLines,
     modified: true,
+    redoStack: [],
     selections: newSelections,
     undoStack: [...editor.undoStack, changes]
   };
@@ -3623,6 +3613,7 @@ const scheduleDocument = async (editor, changes) => {
     ...editor,
     invalidStartIndex,
     lines: newLines,
+    redoStack: [],
     undoStack: [...editor.undoStack, changes]
   };
   const incrementalEdits = await getIncrementalEdits(editor, newEditor);
@@ -3711,6 +3702,7 @@ const emptyEditor = {
   longestLineWidth: 0,
   maxLineY: 0,
   minLineY: 0,
+  redoStack: [],
   scrollBarHeight: 0,
   selectionInfos: [],
   selections: new Uint32Array(),
@@ -4058,6 +4050,7 @@ const createEditor = async ({
     numberOfVisibleLines: 0,
     platform,
     primarySelectionIndex: 0,
+    redoStack: [],
     rowHeight,
     savedSelections,
     scrollBarHeight: 0,
@@ -4132,6 +4125,9 @@ const isEqual$2 = (oldState, newState) => {
 };
 
 const isEqual$1 = (oldState, newState) => {
+  if (!newState.focused) {
+    return true;
+  }
   return oldState.focused === newState.focused && oldState.focus === newState.focus;
 };
 
@@ -4524,7 +4520,7 @@ const y = (editor, rowIndex) => {
   return offsetY;
 };
 
-const state$5 = {
+const state$9 = {
   timeout: -1
 };
 
@@ -4555,7 +4551,7 @@ const editorShowMessage = async (editor, rowIndex, columnIndex, message, isError
 
     // TODO use wrapper timing module instead of this
     // @ts-ignore
-    state$5.timeout = setTimeout(handleTimeout, 3000);
+    state$9.timeout = setTimeout(handleTimeout, 3000);
   }
   return editor;
 };
@@ -4575,8 +4571,8 @@ const showErrorMessage = async (editor, rowIndex, columnIndex, message) => {
 
 // @ts-ignore
 const editorHideMessage = async editor => {
-  clearTimeout(state$5.timeout);
-  state$5.timeout = -1;
+  clearTimeout(state$9.timeout);
+  state$9.timeout = -1;
   // await RendererProcess.invoke(/* Viewlet.send */ 'Viewlet.send', /* id */ editor.uid, /* method */ 'hideOverlayMessage')
   return editor;
 };
@@ -4692,12 +4688,12 @@ const launchRenameWorker = async () => {
   return rpc;
 };
 
-let workerPromise$2;
+const state$8 = {};
 const getOrCreate$2 = () => {
-  if (!workerPromise$2) {
-    workerPromise$2 = launchRenameWorker();
+  if (!state$8.workerPromise) {
+    state$8.workerPromise = launchRenameWorker();
   }
-  return workerPromise$2;
+  return state$8.workerPromise;
 };
 const invoke$5 = async (method, ...params) => {
   const worker = await getOrCreate$2();
@@ -4817,12 +4813,12 @@ const openColorPicker = async editor => {
   return addWidgetToEditor(ColorPicker$1, ColorPicker, editor, create$6, newStateGenerator$6);
 };
 
-const state$4 = {
+const state$7 = {
   compositionText: '',
   isComposing: false
 };
 const compositionStart = (editor, event) => {
-  state$4.isComposing = true;
+  state$7.isComposing = true;
   return editor;
 };
 const getCompositionChanges = (selections, data) => {
@@ -4832,9 +4828,9 @@ const getCompositionChanges = (selections, data) => {
     const selectionStartColumn = selections[i + 1];
     const selectionEndRow = selections[i + 2];
     const selectionEndColumn = selections[i + 3];
-    const startColumnIndex = selectionStartColumn - state$4.compositionText.length;
+    const startColumnIndex = selectionStartColumn - state$7.compositionText.length;
     changes.push({
-      deleted: [state$4.compositionText],
+      deleted: [state$7.compositionText],
       end: {
         columnIndex: selectionEndColumn,
         rowIndex: selectionEndRow
@@ -4854,7 +4850,7 @@ const compositionUpdate = (editor, data) => {
     selections
   } = editor;
   const changes = getCompositionChanges(selections, data);
-  state$4.compositionText = data;
+  state$7.compositionText = data;
   return scheduleDocumentAndCursorsSelections(editor, changes);
 };
 const compositionEnd = (editor, data) => {
@@ -4862,8 +4858,8 @@ const compositionEnd = (editor, data) => {
     selections
   } = editor;
   const changes = getCompositionChanges(selections, data);
-  state$4.isComposing = false;
-  state$4.compositionText = '';
+  state$7.isComposing = false;
+  state$7.compositionText = '';
   return scheduleDocumentAndCursorsSelections(editor, changes);
 };
 
@@ -4932,25 +4928,39 @@ const copy$1 = async editor => {
 };
 
 // TODO handle multiline selection
-// TODO handle multiple cursors
 
 const copyLineDown = editor => {
   const {
     selections
   } = editor;
-  const rowIndex = selections[0];
-  number(rowIndex);
-  const position = {
-    columnIndex: 0,
-    rowIndex
-  };
-  const changes = [{
-    deleted: [''],
-    end: position,
-    inserted: [getLine(editor, rowIndex), ''],
-    start: position
-  }];
-  return scheduleDocumentAndCursorsSelections(editor, changes);
+  const rows = [];
+  for (let i = 0; i < selections.length; i += 4) {
+    const rowIndex = selections[i];
+    number(rowIndex);
+    rows.push(rowIndex);
+  }
+  const uniqueRows = [...new Set(rows)].toSorted((a, b) => a - b);
+  const changes = uniqueRows.map(rowIndex => {
+    const position = {
+      columnIndex: 0,
+      rowIndex
+    };
+    return {
+      deleted: [''],
+      end: position,
+      inserted: [getLine(editor, rowIndex), ''],
+      start: position
+    };
+  });
+  const selectionChanges = new Uint32Array(uniqueRows.length * 4);
+  for (let i = 0; i < uniqueRows.length; i++) {
+    const rowIndex = uniqueRows[i] + i + 1;
+    selectionChanges[i * 4] = rowIndex;
+    selectionChanges[i * 4 + 1] = 0;
+    selectionChanges[i * 4 + 2] = rowIndex;
+    selectionChanges[i * 4 + 3] = 0;
+  }
+  return scheduleDocumentAndCursorsSelections(editor, changes, selectionChanges);
 };
 
 const copyLineUp = editor => {
@@ -5059,8 +5069,14 @@ const characterLeft = (line, columnIndex) => {
   if (!supported()) {
     return 1;
   }
+  if (columnIndex > line.length) {
+    return 1;
+  }
   const segmenter = create$8();
   const last = segmenter.at(line, columnIndex - 1);
+  if (!last) {
+    return 1;
+  }
   // @ts-ignore
   return columnIndex - last.index;
 };
@@ -5939,19 +5955,19 @@ const closeWidgetsMaybe = widgets => {
   return widgets.filter(isPersistentWidget);
 };
 
-const state$3 = {
+const state$6 = {
   position: {
     columnIndex: 0,
     rowIndex: 0
   }
 };
 const getPosition$1 = () => {
-  return state$3.position;
+  return state$6.position;
 };
 
 // @ts-ignore
 const setPosition$1 = position => {
-  state$3.position = position;
+  state$6.position = position;
 };
 
 const openExternal = async (url, platform) => {
@@ -6169,20 +6185,20 @@ const handleMouseDown = (state, button, altKey, ctrlKey, x, y, detail) => {
   }
 };
 
-const state$2 = {
+const state$5 = {
   editor: undefined,
   timeout: -1,
   x: 0,
   y: 0
 };
 const get = () => {
-  return state$2;
+  return state$5;
 };
 const set = (editor, timeout, x, y) => {
-  state$2.editor = editor;
-  state$2.timeout = timeout;
-  state$2.x = x;
-  state$2.y = y;
+  state$5.editor = editor;
+  state$5.timeout = timeout;
+  state$5.x = x;
+  state$5.y = y;
 };
 
 const showHover$1 = async (editor, position) => {
@@ -6323,7 +6339,7 @@ const editorHandleNativeSelectionChange = (editor, range) => {
   return scheduleSelections(editor, selections);
 };
 
-const state$1 = {
+const state$4 = {
   /**
    * @type {any}
    */
@@ -6338,33 +6354,33 @@ const state$1 = {
 
 // @ts-ignore
 const setEditor = editor => {
-  state$1.currentEditor = editor;
-  state$1.hasListener = true;
+  state$4.currentEditor = editor;
+  state$4.hasListener = true;
 };
 const clearEditor = () => {
-  state$1.currentEditor = undefined;
-  state$1.hasListener = false;
-  state$1.isSelecting = false;
+  state$4.currentEditor = undefined;
+  state$4.hasListener = false;
+  state$4.isSelecting = false;
 };
 const startSelecting = () => {
-  state$1.isSelecting = true;
+  state$4.isSelecting = true;
 };
 const isSelecting = () => {
-  return state$1.isSelecting;
+  return state$4.isSelecting;
 };
 
 // @ts-ignore
 const setPosition = position => {
-  state$1.position = position;
+  state$4.position = position;
 };
 const getEditor$1 = () => {
-  return state$1.currentEditor;
+  return state$4.currentEditor;
 };
 const getPosition = () => {
-  return state$1.position;
+  return state$4.position;
 };
 const hasListener = () => {
-  return state$1.hasListener;
+  return state$4.hasListener;
 };
 
 // @ts-ignore
@@ -6744,7 +6760,7 @@ const handleTouchEnd = (editor, touchEvent) => {
   // }
 };
 
-const state = {
+const state$3 = {
   deltaY: 0,
   touchOffsetY: 0
 };
@@ -6755,8 +6771,8 @@ const handleTouchStart = (editor, touchEvent) => {
     return;
   }
   const firstTouch = touchEvent.touches[0];
-  state.touchOffsetY = firstTouch.y;
-  state.deltaY = editor.deltaY;
+  state$3.touchOffsetY = firstTouch.y;
+  state$3.deltaY = editor.deltaY;
   // const position = EditorPosition.at(editor, firstTouch.x, firstTouch.y)
   // EditorMoveSelection.state.position = position
   // state.date = Date.now()
@@ -6797,7 +6813,7 @@ const handleTouchMove = (editor, touchEvent) => {
     return;
   }
   const firstTouch = touchEvent.touches[0];
-  const offsetY = state.deltaY + (state.touchOffsetY - firstTouch.y);
+  const offsetY = state$3.deltaY + (state$3.touchOffsetY - firstTouch.y);
   setDeltaYFixedValue(editor, offsetY);
 };
 
@@ -7288,6 +7304,22 @@ const paste = async editor => {
   return pasteText(editor, text);
 };
 
+const redo = state => {
+  const {
+    redoStack = []
+  } = state;
+  if (redoStack.length === 0) {
+    return state;
+  }
+  const last = redoStack.at(-1);
+  const newState = {
+    ...state,
+    redoStack: redoStack.slice(0, -1),
+    undoStack: [...state.undoStack, last]
+  };
+  return scheduleDocumentAndCursorsSelectionIsUndo(newState, last);
+};
+
 const getErrorMessage$1 = error => {
   if (!error) {
     return `Error: ${error}`;
@@ -7577,10 +7609,7 @@ const isMultiLineMatch = (lines, rowIndex, wordParts) => {
       return false;
     }
   }
-  if (!lines[rowIndex + j].startsWith(wordParts[j])) {
-    return false;
-  }
-  return true;
+  return lines[rowIndex + j].startsWith(wordParts[j]);
 };
 
 // TODO handle virtual space
@@ -7819,7 +7848,13 @@ const getSelectionEditsSingleLineWord = (lines, selections) => {
   const columnIndexAfter = line.indexOf(word, lastSelectionEndColumnIndex);
   if (columnIndexAfter !== -1) {
     const columnIndexAfterEnd = columnIndexAfter + word.length;
-    const newSelections = push(selections, rowIndex, columnIndexAfter, rowIndex, columnIndexAfterEnd);
+    const newSelections = new Uint32Array(selections.length + 4);
+    newSelections.set(selections, 0);
+    const insertIndex = selections.length;
+    newSelections[insertIndex] = rowIndex;
+    newSelections[insertIndex + 1] = columnIndexAfter;
+    newSelections[insertIndex + 2] = rowIndex;
+    newSelections[insertIndex + 3] = columnIndexAfterEnd;
     return {
       revealRange: newSelections.length - 4,
       selectionEdits: newSelections
@@ -7899,13 +7934,12 @@ const getSelectNextOccurrenceResult = editor => {
     for (let i = 0; i < selections.length; i += 4) {
       const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn] = getSelectionPairs(selections, i);
       const wordMatch = getWordMatchAtPosition(lines, selectionStartRow, selectionStartColumn);
+      newSelections[i] = selectionStartRow;
       if (wordMatch.start === wordMatch.end) {
-        newSelections[i] = selectionStartRow;
         newSelections[i + 1] = selectionStartColumn;
         newSelections[i + 2] = selectionEndRow;
         newSelections[i + 3] = selectionEndColumn;
       } else {
-        newSelections[i] = selectionStartRow;
         newSelections[i + 1] = wordMatch.start;
         newSelections[i + 2] = selectionStartRow;
         newSelections[i + 3] = wordMatch.end;
@@ -8165,12 +8199,12 @@ const launchHoverWorker = async () => {
   return rpc;
 };
 
-let workerPromise$1;
+const state$2 = {};
 const getOrCreate$1 = () => {
-  if (!workerPromise$1) {
-    workerPromise$1 = launchHoverWorker();
+  if (!state$2.workerPromise) {
+    state$2.workerPromise = launchHoverWorker();
   }
-  return workerPromise$1;
+  return state$2.workerPromise;
 };
 const invoke$2 = async (method, ...params) => {
   const worker = await getOrCreate$1();
@@ -8249,12 +8283,12 @@ const launchSourceActionWorker = async () => {
   return rpc;
 };
 
-let workerPromise;
+const state$1 = {};
 const getOrCreate = () => {
-  if (!workerPromise) {
-    workerPromise = launchSourceActionWorker();
+  if (!state$1.workerPromise) {
+    state$1.workerPromise = launchSourceActionWorker();
   }
-  return workerPromise;
+  return state$1.workerPromise;
 };
 const invoke$1 = async (method, ...params) => {
   const worker = await getOrCreate();
@@ -8941,10 +8975,14 @@ const undo = state => {
   if (undoStack.length === 0) {
     return state;
   }
-  // TODO avoid side effect?
-  const last = undoStack.pop();
+  const last = undoStack.at(-1);
   const inverseChanges = last.map(inverseChange);
-  return scheduleDocumentAndCursorsSelectionIsUndo(state, inverseChanges);
+  const newState = {
+    ...state,
+    redoStack: [...(state.redoStack || []), last],
+    undoStack: undoStack.slice(0, -1)
+  };
+  return scheduleDocumentAndCursorsSelectionIsUndo(newState, inverseChanges);
 };
 
 // @ts-ignore
@@ -10741,12 +10779,14 @@ const restoreWidgetState = async (keys, savedStates) => {
   return newEditors;
 };
 
-let isReloading = false;
+const state = {
+  isReloading: false
+};
 const hotReload = async () => {
-  if (isReloading) {
+  if (state.isReloading) {
     return;
   }
-  isReloading = true;
+  state.isReloading = true;
 
   // TODO use getEditors
   const keys = getKeys$2();
@@ -10760,7 +10800,7 @@ const hotReload = async () => {
   // TODO ask renderer worker to rerender all editors
   // @ts-ignore
   await invoke$b(`Editor.rerender`);
-  isReloading = false;
+  state.isReloading = false;
 };
 
 const sendMessagePortToSyntaxHighlightingWorker = async port => {
@@ -11661,6 +11701,9 @@ const renderIncremental = (oldState, newState) => {
   const oldDom = getDom(oldState);
   const newDom = getDom(newState);
   const patches = diffTree(oldDom, newDom);
+  if (patches.length === 0) {
+    return [];
+  }
   return [SetPatches, newState.uid, patches];
 };
 
@@ -11885,14 +11928,15 @@ const renderEditor = async id => {
   const commands = [];
   set$7(id, newState, newState);
   for (const item of render$6) {
-    if (!item.isEqual(oldState, newState)) {
-      const result = await item.apply(oldState, newState);
-      // @ts-ignore
-      if (item.multiple) {
-        commands.push(...result);
-      } else if (result.length > 0) {
-        commands.push(result);
-      }
+    if (item.isEqual(oldState, newState)) {
+      continue;
+    }
+    const result = await item.apply(oldState, newState);
+    // @ts-ignore
+    if (item.multiple) {
+      commands.push(...result);
+    } else if (result.length > 0) {
+      commands.push(result);
     }
   }
   return commands;
@@ -12060,64 +12104,63 @@ const wrapCommand = fn => async (editorUid, ...args) => {
   return newEditorWithDerivedState;
 };
 
-const wrapCommandOld = wrapCommand;
 const commandMap = {
   'ActivateByEvent.activateByEvent': activateByEvent,
   'CodeGenerator.accept': codeGeneratorAccept,
   'ColorPicker.loadContent': loadContent$3,
-  'Editor.addCursorAbove': wrapCommandOld(addCursorAbove),
-  'Editor.addCursorBelow': wrapCommandOld(addCursorBelow),
-  'Editor.applyDocumentEdits': wrapCommandOld(applyDocumentEdits),
-  'Editor.applyEdit': wrapCommandOld(applyEdit),
+  'Editor.addCursorAbove': wrapCommand(addCursorAbove),
+  'Editor.addCursorBelow': wrapCommand(addCursorBelow),
+  'Editor.applyDocumentEdits': wrapCommand(applyDocumentEdits),
+  'Editor.applyEdit': wrapCommand(applyEdit),
   'Editor.applyEdit2': applyEdits2,
-  'Editor.applyWorkspaceEdit': wrapCommandOld(applyWorkspaceEdit),
-  'Editor.braceCompletion': wrapCommandOld(braceCompletion),
-  'Editor.cancelSelection': wrapCommandOld(cancelSelection),
-  'Editor.closeCodeGenerator': wrapCommandOld(closeCodeGenerator),
-  'Editor.closeFind': wrapCommandOld(closeFind),
+  'Editor.applyWorkspaceEdit': wrapCommand(applyWorkspaceEdit),
+  'Editor.braceCompletion': wrapCommand(braceCompletion),
+  'Editor.cancelSelection': wrapCommand(cancelSelection),
+  'Editor.closeCodeGenerator': wrapCommand(closeCodeGenerator),
+  'Editor.closeFind': wrapCommand(closeFind),
   'Editor.closeFind2': closeFind2,
-  'Editor.closeRename': wrapCommandOld(closeRename),
-  'Editor.closeSourceAction': wrapCommandOld(closeSourceAction),
+  'Editor.closeRename': wrapCommand(closeRename),
+  'Editor.closeSourceAction': wrapCommand(closeSourceAction),
   'Editor.closeWidget2': closeWidget2,
-  'Editor.compositionEnd': wrapCommandOld(compositionEnd),
-  'Editor.compositionStart': wrapCommandOld(compositionStart),
-  'Editor.compositionUpdate': wrapCommandOld(compositionUpdate),
-  'Editor.contextMenu': wrapCommandOld(handleContextMenu),
-  'Editor.copy': wrapCommandOld(copy$1),
-  'Editor.copyLineDown': wrapCommandOld(copyLineDown),
-  'Editor.copyLineUp': wrapCommandOld(copyLineUp),
+  'Editor.compositionEnd': wrapCommand(compositionEnd),
+  'Editor.compositionStart': wrapCommand(compositionStart),
+  'Editor.compositionUpdate': wrapCommand(compositionUpdate),
+  'Editor.contextMenu': wrapCommand(handleContextMenu),
+  'Editor.copy': wrapCommand(copy$1),
+  'Editor.copyLineDown': wrapCommand(copyLineDown),
+  'Editor.copyLineUp': wrapCommand(copyLineUp),
   'Editor.create': createEditor,
   'Editor.create2': createEditor2,
-  'Editor.cursorCharacterLeft': wrapCommandOld(cursorCharacterLeft),
-  'Editor.cursorCharacterRight': wrapCommandOld(cursorCharacterRight),
-  'Editor.cursorDown': wrapCommandOld(cursorDown),
-  'Editor.cursorEnd': wrapCommandOld(cursorEnd),
-  'Editor.cursorHome': wrapCommandOld(cursorHome),
-  'Editor.cursorLeft': wrapCommandOld(cursorCharacterLeft),
-  'Editor.cursorRight': wrapCommandOld(cursorCharacterRight),
-  'Editor.cursorSet': wrapCommandOld(cursorSet),
-  'Editor.cursorUp': wrapCommandOld(cursorUp),
-  'Editor.cursorWordLeft': wrapCommandOld(cursorWordLeft),
-  'Editor.cursorWordPartLeft': wrapCommandOld(cursorWordPartLeft),
-  'Editor.cursorWordPartRight': wrapCommandOld(cursorWordPartRight),
-  'Editor.cursorWordRight': wrapCommandOld(cursorWordRight),
-  'Editor.cut': wrapCommandOld(cut$1),
-  'Editor.deleteAll': wrapCommandOld(deleteAll),
-  'Editor.deleteAllLeft': wrapCommandOld(deleteAllLeft),
-  'Editor.deleteAllRight': wrapCommandOld(deleteAllRight),
-  'Editor.deleteCharacterLeft': wrapCommandOld(deleteCharacterLeft),
-  'Editor.deleteCharacterRight': wrapCommandOld(deleteCharacterRight),
-  'Editor.deleteHorizontalRight': wrapCommandOld(editorDeleteHorizontalRight),
-  'Editor.deleteLeft': wrapCommandOld(deleteCharacterLeft),
-  'Editor.deleteRight': wrapCommandOld(deleteCharacterRight),
-  'Editor.deleteWordLeft': wrapCommandOld(deleteWordLeft),
-  'Editor.deleteWordPartLeft': wrapCommandOld(deleteWordPartLeft),
-  'Editor.deleteWordPartRight': wrapCommandOld(deleteWordPartRight),
-  'Editor.deleteWordRight': wrapCommandOld(deleteWordRight),
+  'Editor.cursorCharacterLeft': wrapCommand(cursorCharacterLeft),
+  'Editor.cursorCharacterRight': wrapCommand(cursorCharacterRight),
+  'Editor.cursorDown': wrapCommand(cursorDown),
+  'Editor.cursorEnd': wrapCommand(cursorEnd),
+  'Editor.cursorHome': wrapCommand(cursorHome),
+  'Editor.cursorLeft': wrapCommand(cursorCharacterLeft),
+  'Editor.cursorRight': wrapCommand(cursorCharacterRight),
+  'Editor.cursorSet': wrapCommand(cursorSet),
+  'Editor.cursorUp': wrapCommand(cursorUp),
+  'Editor.cursorWordLeft': wrapCommand(cursorWordLeft),
+  'Editor.cursorWordPartLeft': wrapCommand(cursorWordPartLeft),
+  'Editor.cursorWordPartRight': wrapCommand(cursorWordPartRight),
+  'Editor.cursorWordRight': wrapCommand(cursorWordRight),
+  'Editor.cut': wrapCommand(cut$1),
+  'Editor.deleteAll': wrapCommand(deleteAll),
+  'Editor.deleteAllLeft': wrapCommand(deleteAllLeft),
+  'Editor.deleteAllRight': wrapCommand(deleteAllRight),
+  'Editor.deleteCharacterLeft': wrapCommand(deleteCharacterLeft),
+  'Editor.deleteCharacterRight': wrapCommand(deleteCharacterRight),
+  'Editor.deleteHorizontalRight': wrapCommand(editorDeleteHorizontalRight),
+  'Editor.deleteLeft': wrapCommand(deleteCharacterLeft),
+  'Editor.deleteRight': wrapCommand(deleteCharacterRight),
+  'Editor.deleteWordLeft': wrapCommand(deleteWordLeft),
+  'Editor.deleteWordPartLeft': wrapCommand(deleteWordPartLeft),
+  'Editor.deleteWordPartRight': wrapCommand(deleteWordPartRight),
+  'Editor.deleteWordRight': wrapCommand(deleteWordRight),
   'Editor.diff2': diff2,
-  'Editor.executeWidgetCommand': wrapCommandOld(executeWidgetCommand),
-  'Editor.findAllReferences': wrapCommandOld(findAllReferences$1),
-  'Editor.format': wrapCommandOld(format),
+  'Editor.executeWidgetCommand': wrapCommand(executeWidgetCommand),
+  'Editor.findAllReferences': wrapCommand(findAllReferences$1),
+  'Editor.format': wrapCommand(format),
   'Editor.getCommandIds': getCommandIds,
   'Editor.getDiagnostics': getDiagnostics$1,
   'Editor.getKeyBindings': getKeyBindings,
@@ -12141,107 +12184,108 @@ const commandMap = {
   'Editor.getWordAtOffset2': getWordAtOffset2,
   'Editor.getWordBefore': getWordBefore,
   'Editor.getWordBefore2': getWordBefore2,
-  'Editor.goToDefinition': wrapCommandOld(goToDefinition),
-  'Editor.goToTypeDefinition': wrapCommandOld(goToTypeDefinition),
-  'Editor.handleBeforeInput': wrapCommandOld(handleBeforeInput),
-  'Editor.handleBeforeInputFromContentEditable': wrapCommandOld(handleBeforeInputFromContentEditable),
-  'Editor.handleBlur': wrapCommandOld(handleBlur$1),
-  'Editor.handleClickAtPosition': wrapCommandOld(handleClickAtPosition),
-  'Editor.handleContextMenu': wrapCommandOld(handleContextMenu),
-  'Editor.handleDoubleClick': wrapCommandOld(handleDoubleClick),
-  'Editor.handleFocus': wrapCommandOld(handleFocus$1),
-  'Editor.handleMouseDown': wrapCommandOld(handleMouseDown),
-  'Editor.handleMouseMove': wrapCommandOld(handleMouseMove),
-  'Editor.handleMouseMoveWithAltKey': wrapCommandOld(handleMouseMoveWithAltKey),
+  'Editor.goToDefinition': wrapCommand(goToDefinition),
+  'Editor.goToTypeDefinition': wrapCommand(goToTypeDefinition),
+  'Editor.handleBeforeInput': wrapCommand(handleBeforeInput),
+  'Editor.handleBeforeInputFromContentEditable': wrapCommand(handleBeforeInputFromContentEditable),
+  'Editor.handleBlur': wrapCommand(handleBlur$1),
+  'Editor.handleClickAtPosition': wrapCommand(handleClickAtPosition),
+  'Editor.handleContextMenu': wrapCommand(handleContextMenu),
+  'Editor.handleDoubleClick': wrapCommand(handleDoubleClick),
+  'Editor.handleFocus': wrapCommand(handleFocus$1),
+  'Editor.handleMouseDown': wrapCommand(handleMouseDown),
+  'Editor.handleMouseMove': wrapCommand(handleMouseMove),
+  'Editor.handleMouseMoveWithAltKey': wrapCommand(handleMouseMoveWithAltKey),
   'Editor.handleNativeSelectionChange': editorHandleNativeSelectionChange,
-  'Editor.handlePointerCaptureLost': wrapCommandOld(handlePointerCaptureLost),
-  'Editor.handlePointerDown': wrapCommandOld(handlePointerDown$1),
-  'Editor.handlePointerMove': wrapCommandOld(handlePointerMove),
-  'Editor.handlePointerUp': wrapCommandOld(handlePointerUp),
+  'Editor.handlePointerCaptureLost': wrapCommand(handlePointerCaptureLost),
+  'Editor.handlePointerDown': wrapCommand(handlePointerDown$1),
+  'Editor.handlePointerMove': wrapCommand(handlePointerMove),
+  'Editor.handlePointerUp': wrapCommand(handlePointerUp),
   'Editor.handleScrollBarClick': handleScrollBarPointerDown,
-  'Editor.handleScrollBarHorizontalMove': wrapCommandOld(handleScrollBarHorizontalMove),
-  'Editor.handleScrollBarHorizontalPointerDown': wrapCommandOld(handleScrollBarHorizontalPointerDown),
-  'Editor.handleScrollBarMove': wrapCommandOld(handleScrollBarMove),
-  'Editor.handleScrollBarPointerDown': wrapCommandOld(handleScrollBarPointerDown),
-  'Editor.handleScrollBarVerticalMove': wrapCommandOld(handleScrollBarVerticalPointerMove),
-  'Editor.handleScrollBarVerticalPointerDown': wrapCommandOld(handleScrollBarPointerDown),
-  'Editor.handleScrollBarVerticalPointerMove': wrapCommandOld(handleScrollBarVerticalPointerMove),
-  'Editor.handleSingleClick': wrapCommandOld(handleSingleClick),
-  'Editor.handleTab': wrapCommandOld(handleTab),
-  'Editor.handleTouchEnd': wrapCommandOld(handleTouchEnd),
-  'Editor.handleTouchMove': wrapCommandOld(handleTouchMove),
-  'Editor.handleTouchStart': wrapCommandOld(handleTouchStart),
-  'Editor.handleTripleClick': wrapCommandOld(handleTripleClick),
-  'Editor.handleWheel': wrapCommandOld(handleWheel$2),
+  'Editor.handleScrollBarHorizontalMove': wrapCommand(handleScrollBarHorizontalMove),
+  'Editor.handleScrollBarHorizontalPointerDown': wrapCommand(handleScrollBarHorizontalPointerDown),
+  'Editor.handleScrollBarMove': wrapCommand(handleScrollBarMove),
+  'Editor.handleScrollBarPointerDown': wrapCommand(handleScrollBarPointerDown),
+  'Editor.handleScrollBarVerticalMove': wrapCommand(handleScrollBarVerticalPointerMove),
+  'Editor.handleScrollBarVerticalPointerDown': wrapCommand(handleScrollBarPointerDown),
+  'Editor.handleScrollBarVerticalPointerMove': wrapCommand(handleScrollBarVerticalPointerMove),
+  'Editor.handleSingleClick': wrapCommand(handleSingleClick),
+  'Editor.handleTab': wrapCommand(handleTab),
+  'Editor.handleTouchEnd': wrapCommand(handleTouchEnd),
+  'Editor.handleTouchMove': wrapCommand(handleTouchMove),
+  'Editor.handleTouchStart': wrapCommand(handleTouchStart),
+  'Editor.handleTripleClick': wrapCommand(handleTripleClick),
+  'Editor.handleWheel': wrapCommand(handleWheel$2),
   'Editor.hotReload': hotReload,
-  'Editor.indendLess': wrapCommandOld(indentLess),
-  'Editor.indentMore': wrapCommandOld(indentMore),
-  'Editor.insertLineBreak': wrapCommandOld(insertLineBreak),
+  'Editor.indendLess': wrapCommand(indentLess),
+  'Editor.indentMore': wrapCommand(indentMore),
+  'Editor.insertLineBreak': wrapCommand(insertLineBreak),
   'Editor.loadContent': wrapCommand(loadContent),
-  'Editor.moveLineDown': wrapCommandOld(moveLineDown),
-  'Editor.moveLineUp': wrapCommandOld(moveLineUp),
-  'Editor.moveRectangleSelection': wrapCommandOld(moveRectangleSelection),
-  'Editor.moveRectangleSelectionPx': wrapCommandOld(moveRectangleSelectionPx),
-  'Editor.moveSelection': wrapCommandOld(editorMoveSelection),
-  'Editor.moveSelectionPx': wrapCommandOld(moveSelectionPx),
+  'Editor.moveLineDown': wrapCommand(moveLineDown),
+  'Editor.moveLineUp': wrapCommand(moveLineUp),
+  'Editor.moveRectangleSelection': wrapCommand(moveRectangleSelection),
+  'Editor.moveRectangleSelectionPx': wrapCommand(moveRectangleSelectionPx),
+  'Editor.moveSelection': wrapCommand(editorMoveSelection),
+  'Editor.moveSelectionPx': wrapCommand(moveSelectionPx),
   'Editor.offsetAt': offsetAt,
-  'Editor.openCodeGenerator': wrapCommandOld(openCodeGenerator),
-  'Editor.openColorPicker': wrapCommandOld(openColorPicker),
-  'Editor.openCompletion': wrapCommandOld(openCompletion),
-  'Editor.openFind': wrapCommandOld(openFind),
-  'Editor.openFind2': wrapCommandOld(openFind2),
-  'Editor.openRename': wrapCommandOld(openRename),
-  'Editor.organizeImports': wrapCommandOld(organizeImports),
-  'Editor.paste': wrapCommandOld(paste),
-  'Editor.pasteText': wrapCommandOld(pasteText),
+  'Editor.openCodeGenerator': wrapCommand(openCodeGenerator),
+  'Editor.openColorPicker': wrapCommand(openColorPicker),
+  'Editor.openCompletion': wrapCommand(openCompletion),
+  'Editor.openFind': wrapCommand(openFind),
+  'Editor.openFind2': wrapCommand(openFind2),
+  'Editor.openRename': wrapCommand(openRename),
+  'Editor.organizeImports': wrapCommand(organizeImports),
+  'Editor.paste': wrapCommand(paste),
+  'Editor.pasteText': wrapCommand(pasteText),
+  'Editor.redo': wrapCommand(redo),
   'Editor.render': renderEditor,
   'Editor.render2': render2,
   'Editor.renderEventListeners': renderEventListeners,
-  'Editor.replaceRange': wrapCommandOld(replaceRange),
-  'Editor.rerender': wrapCommandOld(rerender),
-  'Editor.save': wrapCommandOld(save),
+  'Editor.replaceRange': wrapCommand(replaceRange),
+  'Editor.rerender': wrapCommand(rerender),
+  'Editor.save': wrapCommand(save),
   'Editor.saveState': wrapGetter(saveState),
-  'Editor.selectAll': wrapCommandOld(selectAll),
-  'Editor.selectAllLeft': wrapCommandOld(editorSelectAllLeft),
-  'Editor.selectAllOccurrences': wrapCommandOld(selectAllOccurrences),
-  'Editor.selectAllRight': wrapCommandOld(editorSelectAllRight),
-  'Editor.selectCharacterLeft': wrapCommandOld(selectCharacterLeft),
-  'Editor.selectCharacterRight': wrapCommandOld(selectCharacterRight),
-  'Editor.selectDown': wrapCommandOld(selectDown),
-  'Editor.selectInsideString': wrapCommandOld(selectInsideString),
-  'Editor.selectionGrow': wrapCommandOld(selectionGrow),
-  'Editor.selectLine': wrapCommandOld(selectLine),
-  'Editor.selectNextOccurrence': wrapCommandOld(selectNextOccurrence),
-  'Editor.selectPreviousOccurrence': wrapCommandOld(selectPreviousOccurrence),
-  'Editor.selectUp': wrapCommandOld(selectUp),
-  'Editor.selectWord': wrapCommandOld(selectWord),
-  'Editor.selectWordLeft': wrapCommandOld(selectWordLeft),
-  'Editor.selectWordRight': wrapCommandOld(selectWordRight),
-  'Editor.setDebugEnabled': wrapCommandOld(setDebugEnabled),
-  'Editor.setDecorations': wrapCommandOld(setDecorations),
-  'Editor.setDelta': wrapCommandOld(setDelta),
-  'Editor.setDeltaY': wrapCommandOld(setDeltaY),
-  'Editor.setLanguageId': wrapCommandOld(setLanguageId),
-  'Editor.setSelections': wrapCommandOld(setSelections),
+  'Editor.selectAll': wrapCommand(selectAll),
+  'Editor.selectAllLeft': wrapCommand(editorSelectAllLeft),
+  'Editor.selectAllOccurrences': wrapCommand(selectAllOccurrences),
+  'Editor.selectAllRight': wrapCommand(editorSelectAllRight),
+  'Editor.selectCharacterLeft': wrapCommand(selectCharacterLeft),
+  'Editor.selectCharacterRight': wrapCommand(selectCharacterRight),
+  'Editor.selectDown': wrapCommand(selectDown),
+  'Editor.selectInsideString': wrapCommand(selectInsideString),
+  'Editor.selectionGrow': wrapCommand(selectionGrow),
+  'Editor.selectLine': wrapCommand(selectLine),
+  'Editor.selectNextOccurrence': wrapCommand(selectNextOccurrence),
+  'Editor.selectPreviousOccurrence': wrapCommand(selectPreviousOccurrence),
+  'Editor.selectUp': wrapCommand(selectUp),
+  'Editor.selectWord': wrapCommand(selectWord),
+  'Editor.selectWordLeft': wrapCommand(selectWordLeft),
+  'Editor.selectWordRight': wrapCommand(selectWordRight),
+  'Editor.setDebugEnabled': wrapCommand(setDebugEnabled),
+  'Editor.setDecorations': wrapCommand(setDecorations),
+  'Editor.setDelta': wrapCommand(setDelta),
+  'Editor.setDeltaY': wrapCommand(setDeltaY),
+  'Editor.setLanguageId': wrapCommand(setLanguageId),
+  'Editor.setSelections': wrapCommand(setSelections),
   'Editor.setSelections2': setSelections2,
-  'Editor.setText': wrapCommandOld(setText),
+  'Editor.setText': wrapCommand(setText),
   'Editor.showHover': showHover,
   'Editor.showHover2': showHover3,
   'Editor.showSourceActions': showSourceActions,
   'Editor.showSourceActions2': showSourceActions,
   'Editor.showSourceActions3': showSourceActions,
-  'Editor.sortLinesAscending': wrapCommandOld(sortLinesAscending),
-  'Editor.tabCompletion': wrapCommandOld(tabCompletion),
+  'Editor.sortLinesAscending': wrapCommand(sortLinesAscending),
+  'Editor.tabCompletion': wrapCommand(tabCompletion),
   'Editor.terminate': terminate,
-  'Editor.toggleBlockComment': wrapCommandOld(toggleBlockComment),
-  'Editor.toggleComment': wrapCommandOld(toggleComment),
-  'Editor.toggleLineComment': wrapCommandOld(editorToggleLineComment),
-  'Editor.type': wrapCommandOld(type),
-  'Editor.typeWithAutoClosing': wrapCommandOld(typeWithAutoClosing),
-  'Editor.undo': wrapCommandOld(undo),
-  'Editor.unIndent': wrapCommandOld(editorUnindent),
+  'Editor.toggleBlockComment': wrapCommand(toggleBlockComment),
+  'Editor.toggleComment': wrapCommand(toggleComment),
+  'Editor.toggleLineComment': wrapCommand(editorToggleLineComment),
+  'Editor.type': wrapCommand(type),
+  'Editor.typeWithAutoClosing': wrapCommand(typeWithAutoClosing),
+  'Editor.undo': wrapCommand(undo),
+  'Editor.unIndent': wrapCommand(editorUnindent),
   'Editor.updateDebugInfo': updateDebugInfo,
-  'Editor.updateDiagnostics': wrapCommandOld(updateDiagnostics),
+  'Editor.updateDiagnostics': wrapCommand(updateDiagnostics),
   'EditorCompletion.close': close$4,
   'EditorCompletion.closeDetails': closeDetails$1,
   'EditorCompletion.focusFirst': focusFirst$1,