@codingame/monaco-vscode-notebook-service-override 15.0.2 → 16.0.0

package/vscode/src/vs/workbench/contrib/notebook/common/services/notebookCellMatching.js

@@ -0,0 +1,173 @@
+
+import { computeLevenshteinDistance } from '@codingame/monaco-vscode-api/vscode/vs/base/common/diff/diff';
+
+function matchCellBasedOnSimilarties(modifiedCells, originalCells) {
+    const cache = {
+        modifiedToOriginal: ( new Map()),
+        originalToModified: ( new Map()),
+    };
+    const results = [];
+    const mappedOriginalCellToModifiedCell = ( new Map());
+    const mappedModifiedIndexes = ( new Set());
+    const originalIndexWithMostEdits = ( new Map());
+    const canOriginalIndexBeMappedToModifiedIndex = (originalIndex, value) => {
+        if (( mappedOriginalCellToModifiedCell.has(originalIndex))) {
+            return false;
+        }
+        const existingEdits = originalIndexWithMostEdits.get(originalIndex)?.dist ?? Number.MAX_SAFE_INTEGER;
+        return value.editCount < existingEdits;
+    };
+    const trackMappedIndexes = (modifiedIndex, originalIndex) => {
+        mappedOriginalCellToModifiedCell.set(originalIndex, modifiedIndex);
+        mappedModifiedIndexes.add(modifiedIndex);
+    };
+    for (let i = 0; i < modifiedCells.length; i++) {
+        const modifiedCell = modifiedCells[i];
+        const { index, editCount: dist, percentage } = computeClosestCell({ cell: modifiedCell, index: i }, originalCells, true, cache, canOriginalIndexBeMappedToModifiedIndex);
+        if (index >= 0 && dist === 0) {
+            trackMappedIndexes(i, index);
+            results.push({ modified: i, original: index, dist, percentage, possibleOriginal: index });
+        }
+        else {
+            originalIndexWithMostEdits.set(index, { dist: dist, modifiedIndex: i });
+            results.push({ modified: i, original: -1, dist: dist, percentage, possibleOriginal: index });
+        }
+    }
+    results.forEach((result, i) => {
+        if (result.original >= 0) {
+            return;
+        }
+        const previousMatchedCell = i > 0 ? results.slice(0, i).reverse().find(r => r.original >= 0) : undefined;
+        const previousMatchedOriginalIndex = previousMatchedCell?.original ?? -1;
+        const previousMatchedModifiedIndex = previousMatchedCell?.modified ?? -1;
+        const matchedCell = results.slice(i + 1).find(r => r.original >= 0);
+        const unavailableIndexes = ( new Set());
+        const nextMatchedModifiedIndex = results.findIndex((item, idx) => idx > i && item.original >= 0);
+        const nextMatchedOriginalIndex = nextMatchedModifiedIndex >= 0 ? results[nextMatchedModifiedIndex].original : -1;
+        originalCells.forEach((_, i) => {
+            if (( mappedOriginalCellToModifiedCell.has(i))) {
+                unavailableIndexes.add(i);
+                return;
+            }
+            if (matchedCell && i >= matchedCell.original) {
+                unavailableIndexes.add(i);
+            }
+            if (nextMatchedOriginalIndex >= 0 && i > nextMatchedOriginalIndex) {
+                unavailableIndexes.add(i);
+            }
+        });
+        const modifiedCell = modifiedCells[i];
+        if (result.original === -1 && result.possibleOriginal >= 0 && !( unavailableIndexes.has(result.possibleOriginal)) && canOriginalIndexBeMappedToModifiedIndex(result.possibleOriginal, { editCount: result.dist })) {
+            trackMappedIndexes(i, result.possibleOriginal);
+            result.original = result.possibleOriginal;
+            return;
+        }
+        if (previousMatchedOriginalIndex > 0 && previousMatchedModifiedIndex > 0 && previousMatchedOriginalIndex === previousMatchedModifiedIndex) {
+            if ((nextMatchedModifiedIndex >= 0 ? nextMatchedModifiedIndex : modifiedCells.length - 1) === (nextMatchedOriginalIndex >= 0 ? nextMatchedOriginalIndex : originalCells.length - 1) && !( unavailableIndexes.has(i)) && i < originalCells.length) {
+                const remainingModifiedItems = (nextMatchedModifiedIndex >= 0 ? nextMatchedModifiedIndex : modifiedCells.length) - previousMatchedModifiedIndex;
+                const remainingOriginalItems = (nextMatchedOriginalIndex >= 0 ? nextMatchedOriginalIndex : originalCells.length) - previousMatchedOriginalIndex;
+                if (remainingModifiedItems === remainingOriginalItems && modifiedCell.cellKind === originalCells[i].cellKind) {
+                    trackMappedIndexes(i, i);
+                    result.original = i;
+                    return;
+                }
+            }
+        }
+        const { index, percentage } = computeClosestCell({ cell: modifiedCell, index: i }, originalCells, false, cache, (originalIndex, originalValue) => {
+            if (( unavailableIndexes.has(originalIndex))) {
+                return false;
+            }
+            if (nextMatchedModifiedIndex > 0 || previousMatchedOriginalIndex > 0) {
+                const matchesForThisOriginalIndex = cache.originalToModified.get(originalIndex);
+                if (matchesForThisOriginalIndex && previousMatchedOriginalIndex < originalIndex) {
+                    const betterMatch = Array.from(matchesForThisOriginalIndex).find(([modifiedIndex, value]) => {
+                        if (modifiedIndex === i) {
+                            return false;
+                        }
+                        if (modifiedIndex >= nextMatchedModifiedIndex) {
+                            return false;
+                        }
+                        if (( mappedModifiedIndexes.has(i))) {
+                            return false;
+                        }
+                        return value.editCount < originalValue.editCount;
+                    });
+                    if (betterMatch) {
+                        return false;
+                    }
+                }
+            }
+            return !( unavailableIndexes.has(originalIndex));
+        });
+        if (index >= 0 && i > 0 && results[i - 1].original === index - 1) {
+            trackMappedIndexes(i, index);
+            results[i].original = index;
+            return;
+        }
+        const nextOriginalCell = (i > 0 && originalCells.length > results[i - 1].original) ? results[i - 1].original + 1 : -1;
+        const nextOriginalCellValue = i > 0 && nextOriginalCell >= 0 && nextOriginalCell < originalCells.length ? originalCells[nextOriginalCell].getValue() : undefined;
+        if (index >= 0 && i > 0 && typeof nextOriginalCellValue === 'string' && !( mappedOriginalCellToModifiedCell.has(nextOriginalCell))) {
+            if (modifiedCell.getValue().includes(nextOriginalCellValue) || nextOriginalCellValue.includes(modifiedCell.getValue())) {
+                trackMappedIndexes(i, nextOriginalCell);
+                results[i].original = nextOriginalCell;
+                return;
+            }
+        }
+        if (percentage < 90 || (i === 0 && results.length === 1)) {
+            trackMappedIndexes(i, index);
+            results[i].original = index;
+            return;
+        }
+    });
+    return results;
+}
+function computeClosestCell({ cell, index: cellIndex }, arr, ignoreEmptyCells, cache, canOriginalIndexBeMappedToModifiedIndex) {
+    let min_edits = Infinity;
+    let min_index = -1;
+    const internalId = cell.internalMetadata?.internalId;
+    if (internalId) {
+        const internalIdIndex = arr.findIndex(cell => cell.internalMetadata?.internalId === internalId);
+        if (internalIdIndex >= 0) {
+            return { index: internalIdIndex, editCount: 0, percentage: Number.MAX_SAFE_INTEGER };
+        }
+    }
+    for (let i = 0; i < arr.length; i++) {
+        if (arr[i].cellKind !== cell.cellKind) {
+            continue;
+        }
+        const str = arr[i].getValue();
+        const cacheEntry = cache.modifiedToOriginal.get(cellIndex) ?? ( new Map());
+        const value = cacheEntry.get(i) ?? { editCount: computeNumberOfEdits(cell, arr[i]), };
+        cacheEntry.set(i, value);
+        cache.modifiedToOriginal.set(cellIndex, cacheEntry);
+        const originalCacheEntry = cache.originalToModified.get(i) ?? ( new Map());
+        originalCacheEntry.set(cellIndex, value);
+        cache.originalToModified.set(i, originalCacheEntry);
+        if (!canOriginalIndexBeMappedToModifiedIndex(i, value)) {
+            continue;
+        }
+        if (str.length === 0 && ignoreEmptyCells) {
+            continue;
+        }
+        if (str === cell.getValue() && cell.getValue().length > 0) {
+            return { index: i, editCount: 0, percentage: 0 };
+        }
+        if (value.editCount < min_edits) {
+            min_edits = value.editCount;
+            min_index = i;
+        }
+    }
+    if (min_index === -1) {
+        return { index: -1, editCount: Number.MAX_SAFE_INTEGER, percentage: Number.MAX_SAFE_INTEGER };
+    }
+    const percentage = !cell.getValue().length && !arr[min_index].getValue().length ? 0 : (cell.getValue().length ? (min_edits * 100 / cell.getValue().length) : Number.MAX_SAFE_INTEGER);
+    return { index: min_index, editCount: min_edits, percentage };
+}
+function computeNumberOfEdits(modified, original) {
+    if (modified.getValue() === original.getValue()) {
+        return 0;
+    }
+    return computeLevenshteinDistance(modified.getValue(), original.getValue());
+}
+
+export { matchCellBasedOnSimilarties };

package/vscode/src/vs/workbench/contrib/notebook/common/services/{notebookSimpleWorker.d.ts → notebookWebWorker.d.ts}

@@ -1,7 +1,6 @@
-import { IDiffResult } from "@codingame/monaco-vscode-api/vscode/vs/base/common/diff/diff";
 import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { IRequestHandler, IWorkerServer } from "@codingame/monaco-vscode-api/vscode/vs/base/common/worker/simpleWorker";
+import { IWebWorkerServerRequestHandler } from "@codingame/monaco-vscode-api/vscode/vs/base/common/worker/webWorker";
 import { CellKind, IMainCellDto, INotebookDiffResult, IOutputDto, NotebookCellInternalMetadata, NotebookCellMetadata, NotebookCellsChangedEventDto, NotebookCellTextModelSplice, NotebookDocumentMetadata, TransientDocumentMetadata } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon";
 import { DefaultEndOfLine } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
 import { IModelChangedEvent } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model/mirrorTextModel";
@@ -19,7 +18,8 @@ declare class MirrorCell {
     constructor(handle: number, uri: URI, source: string[], _eol: string, versionId: number, language: string, cellKind: CellKind, outputs: IOutputDto[], metadata?: NotebookCellMetadata | undefined, internalMetadata?: NotebookCellInternalMetadata | undefined);
     onEvents(e: IModelChangedEvent): void;
     getValue(): string;
-    getComparisonValue(): Promise<number>;
+    getLinesContent(): string[];
+    getComparisonValue(): number;
     private _getHash;
 }
 declare class MirrorNotebookDocument {
@@ -32,7 +32,7 @@ declare class MirrorNotebookDocument {
     private _assertIndex;
     _spliceNotebookCells(splices: NotebookCellTextModelSplice<IMainCellDto>[]): void;
 }
-export declare class NotebookEditorSimpleWorker implements IRequestHandler, IDisposable {
+export declare class NotebookWorker implements IWebWorkerServerRequestHandler, IDisposable {
     _requestHandlerBrand: any;
     private _models;
     constructor();
@@ -42,9 +42,27 @@ export declare class NotebookEditorSimpleWorker implements IRequestHandler, IDis
     $acceptCellModelChanged(strURL: string, handle: number, event: IModelChangedEvent): void;
     $acceptRemovedModel(strURL: string): void;
     $computeDiff(originalUrl: string, modifiedUrl: string): Promise<INotebookDiffResult>;
-    $computeDiffWithCellIds(original: MirrorNotebookDocument, modified: MirrorNotebookDocument): Promise<IDiffResult | undefined>;
+    canComputeDiffWithCellIds(original: MirrorNotebookDocument, modified: MirrorNotebookDocument): boolean;
+    canComputeDiffWithCellInternalIds(original: MirrorNotebookDocument, modified: MirrorNotebookDocument): boolean;
+    canComputeDiffWithCellMetadataIds(original: MirrorNotebookDocument, modified: MirrorNotebookDocument): boolean;
+    isOriginalCellMatchedWithModifiedCell(originalCell: MirrorCell): boolean;
+    updateCellIdsBasedOnMappings(mappings: {
+        modified: number;
+        original: number;
+    }[], originalCells: MirrorCell[], modifiedCells: MirrorCell[]): boolean;
     $canPromptRecommendation(modelUrl: string): boolean;
     protected _getModel(uri: string): MirrorNotebookDocument;
 }
-export declare function create(workerServer: IWorkerServer): IRequestHandler;
+export declare function create(): IWebWorkerServerRequestHandler;
+export type CellDiffInfo = {
+    originalCellIndex: number;
+    modifiedCellIndex: number;
+    type: "unchanged" | "modified";
+} | {
+    originalCellIndex: number;
+    type: "delete";
+} | {
+    modifiedCellIndex: number;
+    type: "insert";
+};
 export {};

package/vscode/src/vs/workbench/contrib/notebook/common/services/notebookWebWorker.js

@@ -0,0 +1,366 @@
+
+import { LcsDiff } from '@codingame/monaco-vscode-api/vscode/vs/base/common/diff/diff';
+import { numberHash, doHash, hash } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { PieceTreeTextBufferBuilder } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/pieceTreeTextBuffer/pieceTreeTextBufferBuilder';
+import { NotebookCellsChangeType, CellKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { SearchParams } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/textModelSearch';
+import { MirrorModel } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/textModelSync/textModelSync.impl';
+import { DefaultEndOfLine } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
+import { filter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+import { matchCellBasedOnSimilarties } from './notebookCellMatching.js';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { DiffChange } from '@codingame/monaco-vscode-api/vscode/vs/base/common/diff/diffChange';
+import { computeDiff } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/notebook/common/notebookDiff';
+
+const PREFIX_FOR_UNMATCHED_ORIGINAL_CELLS = `unmatchedOriginalCell`;
+class MirrorCell {
+    get eol() {
+        return this._eol === '\r\n' ? DefaultEndOfLine.CRLF : DefaultEndOfLine.LF;
+    }
+    constructor(handle, uri, source, _eol, versionId, language, cellKind, outputs, metadata, internalMetadata) {
+        this.handle = handle;
+        this._eol = _eol;
+        this.language = language;
+        this.cellKind = cellKind;
+        this.outputs = outputs;
+        this.metadata = metadata;
+        this.internalMetadata = internalMetadata;
+        this.textModel = ( new MirrorModel(uri, source, _eol, versionId));
+    }
+    onEvents(e) {
+        this.textModel.onEvents(e);
+        this._hash = undefined;
+    }
+    getValue() {
+        return this.textModel.getValue();
+    }
+    getLinesContent() {
+        return this.textModel.getLinesContent();
+    }
+    getComparisonValue() {
+        return this._hash ??= this._getHash();
+    }
+    _getHash() {
+        let hashValue = numberHash(104579, 0);
+        hashValue = doHash(this.language, hashValue);
+        hashValue = doHash(this.getValue(), hashValue);
+        hashValue = doHash(this.metadata, hashValue);
+        hashValue = doHash(this.internalMetadata?.internalId || '', hashValue);
+        for (const op of this.outputs) {
+            hashValue = doHash(op.metadata, hashValue);
+            for (const output of op.outputs) {
+                hashValue = doHash(output.mime, hashValue);
+            }
+        }
+        const digests = this.outputs.flatMap(op => ( op.outputs.map(o => hash(Array.from(o.data.buffer)))));
+        for (const digest of digests) {
+            hashValue = numberHash(digest, hashValue);
+        }
+        return hashValue;
+    }
+}
+class MirrorNotebookDocument {
+    constructor(uri, cells, metadata, transientDocumentMetadata) {
+        this.uri = uri;
+        this.cells = cells;
+        this.metadata = metadata;
+        this.transientDocumentMetadata = transientDocumentMetadata;
+    }
+    acceptModelChanged(event) {
+        event.rawEvents.forEach(e => {
+            if (e.kind === NotebookCellsChangeType.ModelChange) {
+                this._spliceNotebookCells(e.changes);
+            }
+            else if (e.kind === NotebookCellsChangeType.Move) {
+                const cells = this.cells.splice(e.index, 1);
+                this.cells.splice(e.newIdx, 0, ...cells);
+            }
+            else if (e.kind === NotebookCellsChangeType.Output) {
+                const cell = this.cells[e.index];
+                cell.outputs = e.outputs;
+            }
+            else if (e.kind === NotebookCellsChangeType.ChangeCellLanguage) {
+                this._assertIndex(e.index);
+                const cell = this.cells[e.index];
+                cell.language = e.language;
+            }
+            else if (e.kind === NotebookCellsChangeType.ChangeCellMetadata) {
+                this._assertIndex(e.index);
+                const cell = this.cells[e.index];
+                cell.metadata = e.metadata;
+            }
+            else if (e.kind === NotebookCellsChangeType.ChangeCellInternalMetadata) {
+                this._assertIndex(e.index);
+                const cell = this.cells[e.index];
+                cell.internalMetadata = e.internalMetadata;
+            }
+            else if (e.kind === NotebookCellsChangeType.ChangeDocumentMetadata) {
+                this.metadata = e.metadata;
+            }
+        });
+    }
+    _assertIndex(index) {
+        if (index < 0 || index >= this.cells.length) {
+            throw ( new Error(`Illegal index ${index}. Cells length: ${this.cells.length}`));
+        }
+    }
+    _spliceNotebookCells(splices) {
+        splices.reverse().forEach(splice => {
+            const cellDtos = splice[2];
+            const newCells = ( cellDtos.map(cell => {
+                return ( new MirrorCell(cell.handle, ( URI.parse(cell.url)), cell.source, cell.eol, cell.versionId, cell.language, cell.cellKind, cell.outputs, cell.metadata));
+            }));
+            this.cells.splice(splice[0], splice[1], ...newCells);
+        });
+    }
+}
+class CellSequence {
+    static create(textModel) {
+        const hashValue = ( textModel.cells.map(c => c.getComparisonValue()));
+        return ( new CellSequence(hashValue));
+    }
+    static createWithCellId(cells, includeCellContents) {
+        const hashValue = ( cells.map((c) => {
+            if (includeCellContents) {
+                return `${doHash(c.internalMetadata?.internalId, numberHash(104579, 0))}#${c.getComparisonValue()}`;
+            }
+            else {
+                return `${doHash(c.internalMetadata?.internalId, numberHash(104579, 0))}}`;
+            }
+        }));
+        return ( new CellSequence(hashValue));
+    }
+    constructor(hashValue) {
+        this.hashValue = hashValue;
+    }
+    getElements() {
+        return this.hashValue;
+    }
+}
+class NotebookWorker {
+    constructor() {
+        this._models = Object.create(null);
+    }
+    dispose() {
+    }
+    $acceptNewModel(uri, metadata, transientDocumentMetadata, cells) {
+        this._models[uri] = ( new MirrorNotebookDocument(( URI.parse(uri)), ( cells.map(dto => ( new MirrorCell(dto.handle, ( URI.parse(dto.url)), dto.source, dto.eol, dto.versionId, dto.language, dto.cellKind, dto.outputs, dto.metadata, dto.internalMetadata)))), metadata, transientDocumentMetadata));
+    }
+    $acceptModelChanged(strURL, event) {
+        const model = this._models[strURL];
+        model?.acceptModelChanged(event);
+    }
+    $acceptCellModelChanged(strURL, handle, event) {
+        const model = this._models[strURL];
+        model.cells.find(cell => cell.handle === handle)?.onEvents(event);
+    }
+    $acceptRemovedModel(strURL) {
+        if (!this._models[strURL]) {
+            return;
+        }
+        delete this._models[strURL];
+    }
+    async $computeDiff(originalUrl, modifiedUrl) {
+        const original = this._getModel(originalUrl);
+        const modified = this._getModel(modifiedUrl);
+        const originalModel = ( new NotebookTextModelFacade(original));
+        const modifiedModel = ( new NotebookTextModelFacade(modified));
+        const originalMetadata = filter(original.metadata, key => !original.transientDocumentMetadata[key]);
+        const modifiedMetadata = filter(modified.metadata, key => !modified.transientDocumentMetadata[key]);
+        const metadataChanged = JSON.stringify(originalMetadata) !== JSON.stringify(modifiedMetadata);
+        const originalDiff = ( new LcsDiff(CellSequence.create(original), CellSequence.create(modified))).ComputeDiff(false);
+        if (originalDiff.changes.length === 0) {
+            return {
+                metadataChanged,
+                cellsDiff: originalDiff
+            };
+        }
+        const cellMapping = computeDiff(originalModel, modifiedModel, { cellsDiff: { changes: originalDiff.changes, quitEarly: false }}).cellDiffInfo;
+        if (cellMapping.every(c => c.type === 'modified')) {
+            return {
+                metadataChanged,
+                cellsDiff: originalDiff
+            };
+        }
+        let diffUsingCellIds = this.canComputeDiffWithCellIds(original, modified);
+        if (!diffUsingCellIds) {
+            const result = matchCellBasedOnSimilarties(modified.cells, original.cells);
+            if (( result.some(c => c.original !== -1))) {
+                this.updateCellIdsBasedOnMappings(result, original.cells, modified.cells);
+                diffUsingCellIds = true;
+            }
+        }
+        if (!diffUsingCellIds) {
+            return {
+                metadataChanged,
+                cellsDiff: originalDiff
+            };
+        }
+        const cellsInsertedOrDeletedDiff = ( new LcsDiff(
+            CellSequence.createWithCellId(original.cells),
+            CellSequence.createWithCellId(modified.cells)
+        )).ComputeDiff(false);
+        const cellDiffInfo = computeDiff(originalModel, modifiedModel, { cellsDiff: { changes: cellsInsertedOrDeletedDiff.changes, quitEarly: false }}).cellDiffInfo;
+        let processedIndex = 0;
+        const changes = [];
+        cellsInsertedOrDeletedDiff.changes.forEach(change => {
+            if (!change.originalLength && change.modifiedLength) {
+                const changeIndex = cellDiffInfo.findIndex(c => c.type === 'insert' && c.modifiedCellIndex === change.modifiedStart);
+                cellDiffInfo.slice(processedIndex, changeIndex).forEach(c => {
+                    if (c.type === 'unchanged' || c.type === 'modified') {
+                        const originalCell = original.cells[c.originalCellIndex];
+                        const modifiedCell = modified.cells[c.modifiedCellIndex];
+                        const changed = c.type === 'modified' || originalCell.getComparisonValue() !== modifiedCell.getComparisonValue();
+                        if (changed) {
+                            changes.push(( new DiffChange(c.originalCellIndex, 1, c.modifiedCellIndex, 1)));
+                        }
+                    }
+                });
+                changes.push(change);
+                processedIndex = changeIndex + 1;
+            }
+            else if (change.originalLength && !change.modifiedLength) {
+                const changeIndex = cellDiffInfo.findIndex(c => c.type === 'delete' && c.originalCellIndex === change.originalStart);
+                cellDiffInfo.slice(processedIndex, changeIndex).forEach(c => {
+                    if (c.type === 'unchanged' || c.type === 'modified') {
+                        const originalCell = original.cells[c.originalCellIndex];
+                        const modifiedCell = modified.cells[c.modifiedCellIndex];
+                        const changed = c.type === 'modified' || originalCell.getComparisonValue() !== modifiedCell.getComparisonValue();
+                        if (changed) {
+                            changes.push(( new DiffChange(c.originalCellIndex, 1, c.modifiedCellIndex, 1)));
+                        }
+                    }
+                });
+                changes.push(change);
+                processedIndex = changeIndex + 1;
+            }
+            else {
+                const changeIndex = cellDiffInfo.findIndex(c => (c.type === 'delete' && c.originalCellIndex === change.originalStart) || (c.type === 'insert' && c.modifiedCellIndex === change.modifiedStart));
+                cellDiffInfo.slice(processedIndex, changeIndex).forEach(c => {
+                    if (c.type === 'unchanged' || c.type === 'modified') {
+                        const originalCell = original.cells[c.originalCellIndex];
+                        const modifiedCell = modified.cells[c.modifiedCellIndex];
+                        const changed = c.type === 'modified' || originalCell.getComparisonValue() !== modifiedCell.getComparisonValue();
+                        if (changed) {
+                            changes.push(( new DiffChange(c.originalCellIndex, 1, c.modifiedCellIndex, 1)));
+                        }
+                    }
+                });
+                changes.push(change);
+                processedIndex = changeIndex + 1;
+            }
+        });
+        cellDiffInfo.slice(processedIndex).forEach(c => {
+            if (c.type === 'unchanged' || c.type === 'modified') {
+                const originalCell = original.cells[c.originalCellIndex];
+                const modifiedCell = modified.cells[c.modifiedCellIndex];
+                const changed = c.type === 'modified' || originalCell.getComparisonValue() !== modifiedCell.getComparisonValue();
+                if (changed) {
+                    changes.push(( new DiffChange(c.originalCellIndex, 1, c.modifiedCellIndex, 1)));
+                }
+            }
+        });
+        return {
+            metadataChanged,
+            cellsDiff: {
+                changes,
+                quitEarly: false
+            }
+        };
+    }
+    canComputeDiffWithCellIds(original, modified) {
+        return this.canComputeDiffWithCellInternalIds(original, modified) || this.canComputeDiffWithCellMetadataIds(original, modified);
+    }
+    canComputeDiffWithCellInternalIds(original, modified) {
+        const originalCellIndexIds = ( original.cells.map(
+            (cell, index) => ({ index, id: (cell.internalMetadata?.internalId || '') })
+        ));
+        const modifiedCellIndexIds = ( modified.cells.map(
+            (cell, index) => ({ index, id: (cell.internalMetadata?.internalId || '') })
+        ));
+        if (( originalCellIndexIds.some(c => !c.id)) || ( modifiedCellIndexIds.some(c => !c.id))) {
+            return false;
+        }
+        return ( originalCellIndexIds.some(c => modifiedCellIndexIds.find(m => m.id === c.id)));
+    }
+    canComputeDiffWithCellMetadataIds(original, modified) {
+        const originalCellIndexIds = ( original.cells.map((cell, index) => ({ index, id: (cell.metadata?.id || '') })));
+        const modifiedCellIndexIds = ( modified.cells.map((cell, index) => ({ index, id: (cell.metadata?.id || '') })));
+        if (( originalCellIndexIds.some(c => !c.id)) || ( modifiedCellIndexIds.some(c => !c.id))) {
+            return false;
+        }
+        if (originalCellIndexIds.every(c => !modifiedCellIndexIds.find(m => m.id === c.id))) {
+            return false;
+        }
+        return true;
+    }
+    isOriginalCellMatchedWithModifiedCell(originalCell) {
+        return (originalCell.internalMetadata?.internalId || '').startsWith(PREFIX_FOR_UNMATCHED_ORIGINAL_CELLS);
+    }
+    updateCellIdsBasedOnMappings(mappings, originalCells, modifiedCells) {
+        return true;
+    }
+    $canPromptRecommendation(modelUrl) {
+        const model = this._getModel(modelUrl);
+        const cells = model.cells;
+        for (let i = 0; i < cells.length; i++) {
+            const cell = cells[i];
+            if (cell.cellKind === CellKind.Markup) {
+                continue;
+            }
+            if (cell.language !== 'python') {
+                continue;
+            }
+            const searchParams = ( new SearchParams('import\\s*pandas|from\\s*pandas', true, false, null));
+            const searchData = searchParams.parseSearchRequest();
+            if (!searchData) {
+                continue;
+            }
+            const builder = ( new PieceTreeTextBufferBuilder());
+            builder.acceptChunk(cell.getValue());
+            const bufferFactory = builder.finish(true);
+            const textBuffer = bufferFactory.create(cell.eol).textBuffer;
+            const lineCount = textBuffer.getLineCount();
+            const maxLineCount = Math.min(lineCount, 20);
+            const range = ( new Range(1, 1, maxLineCount, textBuffer.getLineLength(maxLineCount) + 1));
+            const cellMatches = textBuffer.findMatchesLineByLine(range, searchData, true, 1);
+            if (cellMatches.length > 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+    _getModel(uri) {
+        return this._models[uri];
+    }
+}
+function create() {
+    return ( new NotebookWorker());
+}
+class NotebookTextModelFacade {
+    constructor(notebook) {
+        this.notebook = notebook;
+        this.cells = ( notebook.cells.map(cell => ( new NotebookCellTextModelFacade(cell))));
+    }
+}
+class NotebookCellTextModelFacade {
+    get cellKind() {
+        return this.cell.cellKind;
+    }
+    constructor(cell) {
+        this.cell = cell;
+    }
+    getHashValue() {
+        return this.cell.getComparisonValue();
+    }
+    equal(cell) {
+        if (cell.cellKind !== this.cellKind) {
+            return false;
+        }
+        return this.getHashValue() === cell.getHashValue();
+    }
+}
+
+export { NotebookWorker, create };

package/vscode/src/vs/workbench/contrib/notebook/common/services/notebookWebWorkerMain.js

@@ -0,0 +1,5 @@
+
+import { bootstrapWebWorker } from '@codingame/monaco-vscode-api/vscode/vs/base/common/worker/webWorkerBootstrap';
+import { create } from './notebookWebWorker.js';
+
+bootstrapWebWorker(create);