@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/notebook/chatEditingNotebookFileSystemProvider.js

@@ -12,21 +12,26 @@ import { ChatEditingNotebookSnapshotScheme } from './chatEditingModifiedNotebook
 
 var ChatEditingNotebookFileSystemProvider_1;
 let ChatEditingNotebookFileSystemProviderContrib = class ChatEditingNotebookFileSystemProviderContrib extends Disposable {
-    static { this.ID = 'chatEditingNotebookFileSystemProviderContribution'; }
+    static {
+        this.ID = "chatEditingNotebookFileSystemProviderContribution";
+    }
     constructor(fileService, instantiationService) {
         super();
         this.fileService = fileService;
         const fileSystemProvider = instantiationService.createInstance(ChatEditingNotebookFileSystemProvider);
-        this._register(this.fileService.registerProvider(ChatEditingNotebookSnapshotScheme, fileSystemProvider));
+        this._register(
+            this.fileService.registerProvider(ChatEditingNotebookSnapshotScheme, fileSystemProvider)
+        );
     }
 };
-ChatEditingNotebookFileSystemProviderContrib = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, IInstantiationService))
-], ChatEditingNotebookFileSystemProviderContrib));
+ChatEditingNotebookFileSystemProviderContrib = ( __decorate([( __param(0, IFileService)), ( __param(1, IInstantiationService))], ChatEditingNotebookFileSystemProviderContrib));
 let ChatEditingNotebookFileSystemProvider = class ChatEditingNotebookFileSystemProvider {
-    static { ChatEditingNotebookFileSystemProvider_1 = this; }
-    static { this.registeredFiles = ( new ResourceMap()); }
+    static {
+        ChatEditingNotebookFileSystemProvider_1 = this;
+    }
+    static {
+        this.registeredFiles = ( new ResourceMap());
+    }
     static registerFile(resource, buffer) {
         ChatEditingNotebookFileSystemProvider_1.registeredFiles.set(resource, buffer);
         return {
@@ -55,19 +60,19 @@ let ChatEditingNotebookFileSystemProvider = class ChatEditingNotebookFileSystemP
         };
     }
     mkdir(_resource) {
-        throw ( new Error('Method not implemented1.'));
+        throw ( new Error("Method not implemented1."));
     }
     readdir(_resource) {
-        throw ( new Error('Method not implemented2.'));
+        throw ( new Error("Method not implemented2."));
     }
     delete(_resource, _opts) {
-        throw ( new Error('Method not implemented3.'));
+        throw ( new Error("Method not implemented3."));
     }
     rename(_from, _to, _opts) {
-        throw ( new Error('Method not implemented4.'));
+        throw ( new Error("Method not implemented4."));
     }
     copy(_from, _to, _opts) {
-        throw ( new Error('Method not implemented5.'));
+        throw ( new Error("Method not implemented5."));
     }
     async readFile(resource) {
         const buffer = ChatEditingNotebookFileSystemProvider_1.registeredFiles.get(resource);
@@ -76,42 +81,40 @@ let ChatEditingNotebookFileSystemProvider = class ChatEditingNotebookFileSystemP
         }
         const queryData = JSON.parse(resource.query);
         if (!queryData.viewType) {
-            throw ( new Error('File not found, viewType not found'));
+            throw ( new Error("File not found, viewType not found"));
         }
         const session = this._chatEditingService.getEditingSession(LocalChatSessionUri.forSession(queryData.sessionId));
         if (!session || !queryData.requestId) {
-            throw ( new Error('File not found, session not found'));
+            throw ( new Error("File not found, session not found"));
         }
         const snapshotEntry = await session.getSnapshotContents(queryData.requestId, resource, queryData.undoStop || undefined);
         if (!snapshotEntry) {
-            throw ( new Error('File not found, snapshot not found'));
+            throw ( new Error("File not found, snapshot not found"));
         }
         return snapshotEntry.buffer;
     }
     writeFile(__resource, _content, _opts) {
-        throw ( new Error('Method not implemented7.'));
+        throw ( new Error("Method not implemented7."));
     }
     readFileStream(__resource, _opts, _token) {
-        throw ( new Error('Method not implemented8.'));
+        throw ( new Error("Method not implemented8."));
     }
     open(__resource, _opts) {
-        throw ( new Error('Method not implemented9.'));
+        throw ( new Error("Method not implemented9."));
     }
     close(_fd) {
-        throw ( new Error('Method not implemented10.'));
+        throw ( new Error("Method not implemented10."));
     }
     read(_fd, _pos, _data, _offset, _length) {
-        throw ( new Error('Method not implemented11.'));
+        throw ( new Error("Method not implemented11."));
     }
     write(_fd, _pos, _data, _offset, _length) {
-        throw ( new Error('Method not implemented12.'));
+        throw ( new Error("Method not implemented12."));
     }
     cloneFile(_from, __to) {
-        throw ( new Error('Method not implemented13.'));
+        throw ( new Error("Method not implemented13."));
     }
 };
-ChatEditingNotebookFileSystemProvider = ChatEditingNotebookFileSystemProvider_1 = ( __decorate([
-    ( __param(0, IChatEditingService))
-], ChatEditingNotebookFileSystemProvider));
+ChatEditingNotebookFileSystemProvider = ChatEditingNotebookFileSystemProvider_1 = ( __decorate([( __param(0, IChatEditingService))], ChatEditingNotebookFileSystemProvider));
 
 export { ChatEditingNotebookFileSystemProvider, ChatEditingNotebookFileSystemProviderContrib };

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/notebook/helpers.js

@@ -2,7 +2,13 @@
 import { CellEditType, NotebookCellsChangeType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
 import { sortCellChanges } from './notebookCellChanges.js';
 
-function adjustCellDiffForRevertingADeletedCell(originalCellIndex, cellDiffInfo, cellToInsert, applyEdits, createModifiedCellDiffInfo) {
+function adjustCellDiffForRevertingADeletedCell(
+    originalCellIndex,
+    cellDiffInfo,
+    cellToInsert,
+    applyEdits,
+    createModifiedCellDiffInfo
+) {
     cellDiffInfo = sortCellChanges(cellDiffInfo);
     const indexOfEntry = cellDiffInfo.findIndex(d => d.originalCellIndex === originalCellIndex);
     if (indexOfEntry === -1) {
@@ -16,15 +22,21 @@ function adjustCellDiffForRevertingADeletedCell(originalCellIndex, cellDiffInfo,
             continue;
         }
         if (i === indexOfEntry) {
-            const edit = { cells: [cellToInsert], count: 0, editType: CellEditType.Replace, index: modifiedCellIndex + 1, };
+            const edit = {
+                cells: [cellToInsert],
+                count: 0,
+                editType: CellEditType.Replace,
+                index: modifiedCellIndex + 1
+            };
             applyEdits([edit], true, undefined, () => undefined, undefined, true);
             cellDiffInfo[i] = createModifiedCellDiffInfo(modifiedCellIndex + 1, originalCellIndex);
             continue;
-        }
-        else {
-            if (typeof diff.modifiedCellIndex === 'number') {
+        } else {
+            if (typeof diff.modifiedCellIndex === "number") {
                 diff.modifiedCellIndex++;
-                cellDiffInfo[i] = { ...diff };
+                cellDiffInfo[i] = {
+                    ...diff
+                };
             }
         }
     }
@@ -34,25 +46,34 @@ function adjustCellDiffForRevertingAnInsertedCell(modifiedCellIndex, cellDiffInf
     if (modifiedCellIndex === -1) {
         return cellDiffInfo;
     }
-    cellDiffInfo = ( sortCellChanges(cellDiffInfo)
-        .filter(d => !(d.type === 'insert' && d.modifiedCellIndex === modifiedCellIndex))
-        .map(d => {
-        if (d.type === 'insert' && d.modifiedCellIndex === modifiedCellIndex) {
+    cellDiffInfo = ( sortCellChanges(cellDiffInfo).filter(d => !(d.type === "insert" && d.modifiedCellIndex === modifiedCellIndex)).map(d => {
+        if (d.type === "insert" && d.modifiedCellIndex === modifiedCellIndex) {
             return d;
         }
-        if (d.type !== 'delete' && d.modifiedCellIndex > modifiedCellIndex) {
+        if (d.type !== "delete" && d.modifiedCellIndex > modifiedCellIndex) {
             return {
                 ...d,
-                modifiedCellIndex: d.modifiedCellIndex - 1,
+                modifiedCellIndex: d.modifiedCellIndex - 1
             };
         }
         return d;
     }));
-    const edit = { cells: [], count: 1, editType: CellEditType.Replace, index: modifiedCellIndex, };
+    const edit = {
+        cells: [],
+        count: 1,
+        editType: CellEditType.Replace,
+        index: modifiedCellIndex
+    };
     applyEdits([edit], true, undefined, () => undefined, undefined, true);
     return cellDiffInfo;
 }
-function adjustCellDiffForKeepingAnInsertedCell(modifiedCellIndex, cellDiffInfo, cellToInsert, applyEdits, createModifiedCellDiffInfo) {
+function adjustCellDiffForKeepingAnInsertedCell(
+    modifiedCellIndex,
+    cellDiffInfo,
+    cellToInsert,
+    applyEdits,
+    createModifiedCellDiffInfo
+) {
     cellDiffInfo = sortCellChanges(cellDiffInfo);
     if (modifiedCellIndex === -1) {
         return cellDiffInfo;
@@ -69,21 +90,34 @@ function adjustCellDiffForKeepingAnInsertedCell(modifiedCellIndex, cellDiffInfo,
             continue;
         }
         if (i === indexOfEntry) {
-            const edit = { cells: [cellToInsert], count: 0, editType: CellEditType.Replace, index: originalCellIndex + 1 };
+            const edit = {
+                cells: [cellToInsert],
+                count: 0,
+                editType: CellEditType.Replace,
+                index: originalCellIndex + 1
+            };
             applyEdits([edit], true, undefined, () => undefined, undefined, true);
             cellDiffInfo[i] = createModifiedCellDiffInfo(modifiedCellIndex, originalCellIndex + 1);
             continue;
-        }
-        else {
-            if (typeof diff.originalCellIndex === 'number') {
+        } else {
+            if (typeof diff.originalCellIndex === "number") {
                 diff.originalCellIndex++;
-                cellDiffInfo[i] = { ...diff };
+                cellDiffInfo[i] = {
+                    ...diff
+                };
             }
         }
     }
     return cellDiffInfo;
 }
-function adjustCellDiffAndOriginalModelBasedOnCellAddDelete(change, cellDiffInfo, modifiedModelCellCount, originalModelCellCount, applyEdits, createModifiedCellDiffInfo) {
+function adjustCellDiffAndOriginalModelBasedOnCellAddDelete(
+    change,
+    cellDiffInfo,
+    modifiedModelCellCount,
+    originalModelCellCount,
+    applyEdits,
+    createModifiedCellDiffInfo
+) {
     cellDiffInfo = sortCellChanges(cellDiffInfo);
     const numberOfCellsInserted = change[2].length;
     const numberOfCellsDeleted = change[1];
@@ -103,14 +137,14 @@ function adjustCellDiffAndOriginalModelBasedOnCellAddDelete(change, cellDiffInfo
     if (cells.length) {
         for (let i = 0; i < cellDiffInfo.length; i++) {
             const diff = cellDiffInfo[i];
-            if (typeof diff.modifiedCellIndex === 'number' && diff.modifiedCellIndex === change[0]) {
+            if (typeof diff.modifiedCellIndex === "number" && diff.modifiedCellIndex === change[0]) {
                 diffEntryIndex = i;
-                if (typeof diff.originalCellIndex === 'number') {
+                if (typeof diff.originalCellIndex === "number") {
                     indexToInsertInOriginalModel = diff.originalCellIndex;
                 }
                 break;
             }
-            if (typeof diff.originalCellIndex === 'number') {
+            if (typeof diff.originalCellIndex === "number") {
                 indexToInsertInOriginalModel = diff.originalCellIndex + 1;
             }
         }
@@ -136,30 +170,30 @@ function adjustCellDiffAndOriginalModelBasedOnCellAddDelete(change, cellDiffInfo
                 continue;
             }
             let changed = false;
-            if (typeof diff.modifiedCellIndex === 'number' && ( modifiedIndexesToRemove.has(diff.modifiedCellIndex))) {
+            if (typeof diff.modifiedCellIndex === "number" && ( modifiedIndexesToRemove.has(diff.modifiedCellIndex))) {
                 numberOfModifiedCellsRemovedSoFar++;
-                if (typeof diff.originalCellIndex === 'number') {
+                if (typeof diff.originalCellIndex === "number") {
                     numberOfOriginalCellsRemovedSoFar++;
                 }
                 itemsToRemove.add(diff);
                 continue;
             }
-            if (typeof diff.modifiedCellIndex === 'number' && numberOfModifiedCellsRemovedSoFar) {
+            if (typeof diff.modifiedCellIndex === "number" && numberOfModifiedCellsRemovedSoFar) {
                 diff.modifiedCellIndex -= numberOfModifiedCellsRemovedSoFar;
                 changed = true;
             }
-            if (typeof diff.originalCellIndex === 'number' && numberOfOriginalCellsRemovedSoFar) {
+            if (typeof diff.originalCellIndex === "number" && numberOfOriginalCellsRemovedSoFar) {
                 diff.originalCellIndex -= numberOfOriginalCellsRemovedSoFar;
                 changed = true;
             }
             if (changed) {
-                cellDiffInfo[i] = { ...diff };
+                cellDiffInfo[i] = {
+                    ...diff
+                };
             }
         }
         if (itemsToRemove.size) {
-            Array.from(itemsToRemove)
-                .filter(diff => typeof diff.originalCellIndex === 'number')
-                .forEach(diff => {
+            Array.from(itemsToRemove).filter(diff => typeof diff.originalCellIndex === "number").forEach(diff => {
                 const edit = {
                     editType: CellEditType.Replace,
                     cells: [],
@@ -178,16 +212,18 @@ function adjustCellDiffAndOriginalModelBasedOnCellAddDelete(change, cellDiffInfo
                 continue;
             }
             let changed = false;
-            if (typeof diff.modifiedCellIndex === 'number') {
+            if (typeof diff.modifiedCellIndex === "number") {
                 diff.modifiedCellIndex += numberOfCellsInserted;
                 changed = true;
             }
-            if (typeof diff.originalCellIndex === 'number') {
+            if (typeof diff.originalCellIndex === "number") {
                 diff.originalCellIndex += numberOfCellsInserted;
                 changed = true;
             }
             if (changed) {
-                cellDiffInfo[i] = { ...diff };
+                cellDiffInfo[i] = {
+                    ...diff
+                };
             }
         }
     }
@@ -195,7 +231,11 @@ function adjustCellDiffAndOriginalModelBasedOnCellAddDelete(change, cellDiffInfo
         const originalCellIndex = i + (indexToInsertInOriginalModel ?? 0);
         const modifiedCellIndex = change[0] + i;
         const unchangedCell = createModifiedCellDiffInfo(modifiedCellIndex, originalCellIndex);
-        cellDiffInfo.splice((diffEntryIndex === -1 ? cellDiffInfo.length : diffEntryIndex) + i, 0, unchangedCell);
+        cellDiffInfo.splice(
+            (diffEntryIndex === -1 ? cellDiffInfo.length : diffEntryIndex) + i,
+            0,
+            unchangedCell
+        );
     });
     return cellDiffInfo;
 }
@@ -208,35 +248,36 @@ function adjustCellDiffAndOriginalModelBasedOnCellMovements(event, cellDiffInfo)
     if (indexOfEntry === -1 || indexOfEntryToPlaceBelow === -1) {
         return undefined;
     }
-    const entryToBeMoved = { ...cellDiffs[indexOfEntry] };
-    const moveDirection = event.newIdx > event.index ? 'down' : 'up';
+    const entryToBeMoved = {
+        ...cellDiffs[indexOfEntry]
+    };
+    const moveDirection = event.newIdx > event.index ? "down" : "up";
     const startIndex = cellDiffs.findIndex(d => d.modifiedCellIndex === minimumIndex);
     const endIndex = cellDiffs.findIndex(d => d.modifiedCellIndex === maximumIndex);
-    const movingExistingCell = typeof entryToBeMoved.originalCellIndex === 'number';
+    const movingExistingCell = typeof entryToBeMoved.originalCellIndex === "number";
     let originalCellsWereEffected = false;
     for (let i = 0; i < cellDiffs.length; i++) {
         const diff = cellDiffs[i];
         let changed = false;
-        if (moveDirection === 'down') {
+        if (moveDirection === "down") {
             if (i > startIndex && i <= endIndex) {
-                if (typeof diff.modifiedCellIndex === 'number') {
+                if (typeof diff.modifiedCellIndex === "number") {
                     changed = true;
                     diff.modifiedCellIndex = diff.modifiedCellIndex - 1;
                 }
-                if (typeof diff.originalCellIndex === 'number' && movingExistingCell) {
+                if (typeof diff.originalCellIndex === "number" && movingExistingCell) {
                     diff.originalCellIndex = diff.originalCellIndex - 1;
                     originalCellsWereEffected = true;
                     changed = true;
                 }
             }
-        }
-        else {
+        } else {
             if (i >= startIndex && i < endIndex) {
-                if (typeof diff.modifiedCellIndex === 'number') {
+                if (typeof diff.modifiedCellIndex === "number") {
                     changed = true;
                     diff.modifiedCellIndex = diff.modifiedCellIndex + 1;
                 }
-                if (typeof diff.originalCellIndex === 'number' && movingExistingCell) {
+                if (typeof diff.originalCellIndex === "number" && movingExistingCell) {
                     diff.originalCellIndex = diff.originalCellIndex + 1;
                     originalCellsWereEffected = true;
                     changed = true;
@@ -244,26 +285,33 @@ function adjustCellDiffAndOriginalModelBasedOnCellMovements(event, cellDiffInfo)
             }
         }
         if (changed) {
-            cellDiffs[i] = { ...diff };
+            cellDiffs[i] = {
+                ...diff
+            };
         }
     }
     entryToBeMoved.modifiedCellIndex = event.newIdx;
     const originalCellIndex = entryToBeMoved.originalCellIndex;
-    if (moveDirection === 'down') {
+    if (moveDirection === "down") {
         cellDiffs.splice(endIndex + 1, 0, entryToBeMoved);
         cellDiffs.splice(startIndex, 1);
-        if (typeof entryToBeMoved.originalCellIndex === 'number') {
-            entryToBeMoved.originalCellIndex = cellDiffs.slice(0, endIndex).reduce((lastOriginalIndex, diff) => typeof diff.originalCellIndex === 'number' ? Math.max(lastOriginalIndex, diff.originalCellIndex) : lastOriginalIndex, -1) + 1;
+        if (typeof entryToBeMoved.originalCellIndex === "number") {
+            entryToBeMoved.originalCellIndex = cellDiffs.slice(0, endIndex).reduce(
+                (lastOriginalIndex, diff) => typeof diff.originalCellIndex === "number" ? Math.max(lastOriginalIndex, diff.originalCellIndex) : lastOriginalIndex,
+                -1
+            ) + 1;
         }
-    }
-    else {
+    } else {
         cellDiffs.splice(endIndex, 1);
         cellDiffs.splice(startIndex, 0, entryToBeMoved);
-        if (typeof entryToBeMoved.originalCellIndex === 'number') {
-            entryToBeMoved.originalCellIndex = cellDiffs.slice(0, startIndex).reduce((lastOriginalIndex, diff) => typeof diff.originalCellIndex === 'number' ? Math.max(lastOriginalIndex, diff.originalCellIndex) : lastOriginalIndex, -1) + 1;
+        if (typeof entryToBeMoved.originalCellIndex === "number") {
+            entryToBeMoved.originalCellIndex = cellDiffs.slice(0, startIndex).reduce(
+                (lastOriginalIndex, diff) => typeof diff.originalCellIndex === "number" ? Math.max(lastOriginalIndex, diff.originalCellIndex) : lastOriginalIndex,
+                -1
+            ) + 1;
         }
     }
-    if (typeof entryToBeMoved.originalCellIndex === 'number' && originalCellsWereEffected && typeof originalCellIndex === 'number' && entryToBeMoved.originalCellIndex !== originalCellIndex) {
+    if (typeof entryToBeMoved.originalCellIndex === "number" && originalCellsWereEffected && typeof originalCellIndex === "number" && entryToBeMoved.originalCellIndex !== originalCellIndex) {
         const edit = {
             editType: CellEditType.Move,
             index: originalCellIndex,
@@ -279,14 +327,17 @@ function getCorrespondingOriginalCellIndex(modifiedCellIndex, cellDiffInfo) {
     return entry?.originalCellIndex;
 }
 function isTransientIPyNbExtensionEvent(notebookKind, e) {
-    if (notebookKind !== 'jupyter-notebook') {
+    if (notebookKind !== "jupyter-notebook") {
         return false;
     }
     if (e.rawEvents.every(event => {
         if (event.kind !== NotebookCellsChangeType.ChangeCellMetadata) {
             return false;
         }
-        if (JSON.stringify(event.metadata || {}) === JSON.stringify({ execution_count: null, metadata: {} })) {
+        if (JSON.stringify(event.metadata || {}) === JSON.stringify({
+            execution_count: null,
+            metadata: {}
+        })) {
             return true;
         }
         return true;
@@ -298,13 +349,13 @@ function isTransientIPyNbExtensionEvent(notebookKind, e) {
 function calculateNotebookRewriteRatio(cellsDiff, originalModel, modifiedModel) {
     const totalNumberOfUpdatedLines = cellsDiff.reduce((totalUpdatedLines, value) => {
         const getUpadtedLineCount = () => {
-            if (value.type === 'unchanged') {
+            if (value.type === "unchanged") {
                 return 0;
             }
-            if (value.type === 'delete') {
+            if (value.type === "delete") {
                 return originalModel.cells[value.originalCellIndex].textModel?.getLineCount() ?? 0;
             }
-            if (value.type === 'insert') {
+            if (value.type === "insert") {
                 return modifiedModel.cells[value.modifiedCellIndex].textModel?.getLineCount() ?? 0;
             }
             return value.diff.get().changes.reduce((maxLineNumber, change) => {
@@ -313,7 +364,10 @@ function calculateNotebookRewriteRatio(cellsDiff, originalModel, modifiedModel)
         };
         return totalUpdatedLines + getUpadtedLineCount();
     }, 0);
-    const totalNumberOfLines = modifiedModel.cells.reduce((totalLines, cell) => totalLines + (cell.textModel?.getLineCount() ?? 0), 0);
+    const totalNumberOfLines = modifiedModel.cells.reduce(
+        (totalLines, cell) => totalLines + (cell.textModel?.getLineCount() ?? 0),
+        0
+    );
     return totalNumberOfLines === 0 ? 0 : Math.min(1, totalNumberOfUpdatedLines / totalNumberOfLines);
 }
 

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/notebook/notebookCellChanges.js

@@ -7,14 +7,14 @@ function countChanges(changes) {
             return count;
         }
         switch (change.type) {
-            case 'delete':
-                return count + 1;
-            case 'insert':
-                return count + 1;
-            case 'modified':
-                return count + diff.changes.length;
-            default:
-                return count;
+        case "delete":
+            return count + 1;
+        case "insert":
+            return count + 1;
+        case "modified":
+            return count + diff.changes.length;
+        default:
+            return count;
         }
     }, 0);
 }
@@ -22,29 +22,26 @@ function sortCellChanges(changes) {
     const indexes = ( new Map());
     changes.forEach((c, i) => indexes.set(c, i));
     return [...changes].sort((a, b) => {
-        if ((a.type === 'unchanged' || a.type === 'modified') &&
-            (b.type === 'unchanged' || b.type === 'modified')) {
+        if ((a.type === "unchanged" || a.type === "modified") && (b.type === "unchanged" || b.type === "modified")) {
             return a.modifiedCellIndex - b.modifiedCellIndex;
         }
-        if (a.type === 'delete' && b.type === 'delete') {
+        if (a.type === "delete" && b.type === "delete") {
             return a.originalCellIndex - b.originalCellIndex;
         }
-        if (a.type === 'insert' && b.type === 'insert') {
+        if (a.type === "insert" && b.type === "insert") {
             return a.modifiedCellIndex - b.modifiedCellIndex;
         }
-        if (a.type === 'delete' && b.type === 'insert') {
+        if (a.type === "delete" && b.type === "insert") {
             return indexes.get(a) - indexes.get(b);
         }
-        if (a.type === 'insert' && b.type === 'delete') {
+        if (a.type === "insert" && b.type === "delete") {
             return indexes.get(a) - indexes.get(b);
         }
-        if ((a.type === 'delete' && b.type !== 'insert') || (a.type !== 'insert' && b.type === 'delete')) {
+        if ((a.type === "delete" && b.type !== "insert") || (a.type !== "insert" && b.type === "delete")) {
             return a.originalCellIndex - b.originalCellIndex;
         }
-        const aIndex = a.type === 'delete' ? a.originalCellIndex :
-            (a.type === 'insert' ? a.modifiedCellIndex : a.modifiedCellIndex);
-        const bIndex = b.type === 'delete' ? b.originalCellIndex :
-            (b.type === 'insert' ? b.modifiedCellIndex : b.modifiedCellIndex);
+        const aIndex = a.type === "delete" ? a.originalCellIndex : (a.type === "insert" ? a.modifiedCellIndex : a.modifiedCellIndex);
+        const bIndex = b.type === "delete" ? b.originalCellIndex : (b.type === "insert" ? b.modifiedCellIndex : b.modifiedCellIndex);
         return aIndex - bIndex;
     });
 }