@codingame/monaco-vscode-notebook-service-override 14.0.6 → 15.0.0

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookInlineVariables.js

@@ -1,32 +1,30 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { CancellationTokenSource, CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { onUnexpectedExternalError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
-import { format, noBreakWhitespace } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
-import { Constants } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uint';
+import { format } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { Position } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position';
 import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
-import { InjectedTextCursorStops } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
-import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures';
+import { StandardTokenType } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/encodedTokenAttributes';
+import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { registerAction2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { createInlineValueDecoration } from '@codingame/monaco-vscode-88aa9a78-75f5-5aaa-89e9-bbdd580b3b5c-common/vscode/vs/workbench/contrib/debug/browser/debugEditorContribution';
 import { State } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/debug/common/debug';
 import { IDebugService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/debug/common/debug.service';
 import { NotebookSetting } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { NotebookExecutionType } from '@codingame/monaco-vscode-af5ccfda-af82-504b-b365-92b4e654e5c5-common/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService';
+import { NotebookExecutionType } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService';
 import { INotebookExecutionStateService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService.service';
 import { INotebookKernelService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookKernelService.service';
-import { NotebookAction } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/browser/controller/coreActions';
-import { registerNotebookContribution } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
+import { NotebookAction } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/notebook/browser/controller/coreActions';
+import { registerNotebookContribution } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
 
-const MAX_INLINE_DECORATOR_LENGTH = 150;
-const variableRegex = ( new RegExp(
-'(?:[a-zA-Z_][a-zA-Z0-9_]*\\.)*' +
-    '[a-zA-Z_][a-zA-Z0-9_]*', 'g'));
+var NotebookInlineVariablesController_1;
 class InlineSegment {
     constructor(column, text) {
         this.column = column;
@@ -34,7 +32,9 @@ class InlineSegment {
     }
 }
 let NotebookInlineVariablesController = class NotebookInlineVariablesController extends Disposable {
+    static { NotebookInlineVariablesController_1 = this; }
     static { this.id = 'notebook.inlineVariablesController'; }
+    static { this.MAX_CELL_LINES = 5000; }
     constructor(notebookEditor, notebookKernelService, notebookExecutionStateService, languageFeaturesService, configurationService, debugService) {
         super();
         this.notebookEditor = notebookEditor;
@@ -47,7 +47,8 @@ let NotebookInlineVariablesController = class NotebookInlineVariablesController
         this.cellContentListeners = ( new ResourceMap());
         this.currentCancellationTokenSources = ( new ResourceMap());
         this._register(this.notebookExecutionStateService.onDidChangeExecution(async (e) => {
-            if (!this.configurationService.getValue(NotebookSetting.notebookInlineValues)) {
+            const inlineValuesSetting = this.configurationService.getValue(NotebookSetting.notebookInlineValues);
+            if (inlineValuesSetting === 'off') {
                 return;
             }
             if (e.type === NotebookExecutionType.cell) {
@@ -56,7 +57,7 @@ let NotebookInlineVariablesController = class NotebookInlineVariablesController
         }));
         this._register(Event.runAndSubscribe(this.configurationService.onDidChangeConfiguration, e => {
             if (!e || e.affectsConfiguration(NotebookSetting.notebookInlineValues)) {
-                if (!this.configurationService.getValue(NotebookSetting.notebookInlineValues)) {
+                if (this.configurationService.getValue(NotebookSetting.notebookInlineValues) === 'off') {
                     this.clearNotebookInlineDecorations();
                 }
             }
@@ -87,9 +88,14 @@ let NotebookInlineVariablesController = class NotebookInlineVariablesController
         if (!model) {
             return;
         }
+        const inlineValuesSetting = this.configurationService.getValue(NotebookSetting.notebookInlineValues);
+        const hasInlineValueProvider = ( this.languageFeaturesService.inlineValuesProvider.has(model));
+        if (inlineValuesSetting === 'off' || (inlineValuesSetting === 'auto' && !hasInlineValueProvider)) {
+            return;
+        }
         this.clearCellInlineDecorations(cell);
         const inlineDecorations = [];
-        if (( this.languageFeaturesService.inlineValuesProvider.has(model))) {
+        if (hasInlineValueProvider) {
             const lastLine = model.getLineCount();
             const lastColumn = model.getLineMaxColumn(lastLine);
             const ctx = {
@@ -100,54 +106,57 @@ let NotebookInlineVariablesController = class NotebookInlineVariablesController
             const lineDecorations = ( new Map());
             const fullCellRange = ( new Range(1, 1, lastLine, lastColumn));
             const promises = providers.flatMap(provider => Promise.resolve(provider.provideInlineValues(model, fullCellRange, ctx, token)).then(async (result) => {
-                if (result) {
-                    let kernel;
-                    const kernelVars = [];
-                    if (( result.some(iv => iv.type === 'variable'))) {
-                        if (!this.notebookEditor.hasModel()) {
-                            return;
-                        }
-                        kernel = this.notebookKernelService.getMatchingKernel(this.notebookEditor.textModel);
-                        const variables = kernel.selected?.provideVariables(event.notebook, undefined, 'named', 0, token);
-                        if (!variables) {
-                            return;
-                        }
+                if (!result) {
+                    return;
+                }
+                const notebook = this.notebookEditor.textModel;
+                if (!notebook) {
+                    return;
+                }
+                const kernel = this.notebookKernelService.getMatchingKernel(notebook);
+                const kernelVars = [];
+                if (( result.some(iv => iv.type === 'variable'))) {
+                    if (!this.notebookEditor.hasModel()) {
+                        return;
+                    }
+                    const variables = kernel.selected?.provideVariables(event.notebook, undefined, 'named', 0, token);
+                    if (variables) {
                         for await (const v of variables) {
                             kernelVars.push(v);
                         }
                     }
-                    for (const iv of result) {
-                        let text = undefined;
-                        switch (iv.type) {
-                            case 'text':
-                                text = iv.text;
-                                break;
-                            case 'variable': {
-                                const name = iv.variableName;
-                                if (!name) {
-                                    continue;
-                                }
-                                const value = kernelVars.find(v => v.name === name)?.value;
-                                if (!value) {
-                                    continue;
-                                }
-                                text = format('{0} = {1}', name, value);
-                                break;
+                }
+                for (const iv of result) {
+                    let text = undefined;
+                    switch (iv.type) {
+                        case 'text':
+                            text = iv.text;
+                            break;
+                        case 'variable': {
+                            const name = iv.variableName;
+                            if (!name) {
+                                continue;
                             }
-                            case 'expression': {
+                            const value = kernelVars.find(v => v.name === name)?.value;
+                            if (!value) {
                                 continue;
                             }
+                            text = format('{0} = {1}', name, value);
+                            break;
                         }
-                        if (text) {
-                            const line = iv.range.startLineNumber;
-                            let lineSegments = lineDecorations.get(line);
-                            if (!lineSegments) {
-                                lineSegments = [];
-                                lineDecorations.set(line, lineSegments);
-                            }
-                            if (!( lineSegments.some(iv => iv.text === text))) {
-                                lineSegments.push(( new InlineSegment(iv.range.startColumn, text)));
-                            }
+                        case 'expression': {
+                            continue;
+                        }
+                    }
+                    if (text) {
+                        const line = iv.range.startLineNumber;
+                        let lineSegments = lineDecorations.get(line);
+                        if (!lineSegments) {
+                            lineSegments = [];
+                            lineDecorations.set(line, lineSegments);
+                        }
+                        if (!( lineSegments.some(iv => iv.text === text))) {
+                            lineSegments.push(( new InlineSegment(iv.range.startColumn, text)));
                         }
                     }
                 }
@@ -157,18 +166,28 @@ let NotebookInlineVariablesController = class NotebookInlineVariablesController
             await Promise.all(promises);
             lineDecorations.forEach((segments, line) => {
                 if (segments.length > 0) {
-                    segments = segments.sort((a, b) => a.column - b.column);
+                    segments.sort((a, b) => a.column - b.column);
                     const text = ( segments.map(s => s.text)).join(', ');
-                    inlineDecorations.push(...this.createNotebookInlineValueDecoration(line, text));
+                    const editorWidth = cell.layoutInfo.editorWidth;
+                    const fontInfo = cell.layoutInfo.fontInfo;
+                    if (fontInfo && cell.textModel) {
+                        const base = Math.floor((editorWidth - 50) / fontInfo.typicalHalfwidthCharacterWidth);
+                        const lineLength = cell.textModel.getLineLength(line);
+                        const available = Math.max(0, base - lineLength);
+                        inlineDecorations.push(...createInlineValueDecoration(line, text, 'nb', undefined, available));
+                    }
+                    else {
+                        inlineDecorations.push(...createInlineValueDecoration(line, text, 'nb'));
+                    }
                 }
             });
         }
-        else {
+        else if (inlineValuesSetting === 'on') {
             if (!this.notebookEditor.hasModel()) {
                 return;
             }
             const kernel = this.notebookKernelService.getMatchingKernel(this.notebookEditor.textModel);
-            const variables = kernel?.selected?.provideVariables(event.notebook, undefined, 'named', 0, CancellationToken.None);
+            const variables = kernel?.selected?.provideVariables(event.notebook, undefined, 'named', 0, token);
             if (!variables) {
                 return;
             }
@@ -181,24 +200,259 @@ let NotebookInlineVariablesController = class NotebookInlineVariablesController
             if (!document) {
                 return;
             }
-            for (let i = 1; i <= document.getLineCount(); i++) {
-                const line = document.getLineContent(i);
-                if (line.trimStart().startsWith('#')) {
+            if (document.getLineCount() > NotebookInlineVariablesController_1.MAX_CELL_LINES) {
+                return;
+            }
+            const inlineDecorations = [];
+            const processedVars = ( new Set());
+            const functionRanges = this.getFunctionRanges(document);
+            const commentedRanges = this.getCommentedRanges(document);
+            const ignoredRanges = [...functionRanges, ...commentedRanges];
+            const lineDecorations = ( new Map());
+            for (const varName of varNames) {
+                if (( processedVars.has(varName))) {
                     continue;
                 }
-                for (let match = variableRegex.exec(line); match; match = variableRegex.exec(line)) {
-                    const name = match[0];
-                    if (varNames.includes(name)) {
-                        const inlineVal = name + ' = ' + vars.find(v => v.name === name)?.value;
-                        inlineDecorations.push(...this.createNotebookInlineValueDecoration(i, inlineVal));
+                const regex = ( new RegExp(`\\b${varName}\\b(?!\\w)`, 'g'));
+                let lastMatchOutsideIgnored = null;
+                let foundMatch = false;
+                const lines = document.getValue().split('\n');
+                for (let lineNumber = lines.length - 1; lineNumber >= 0; lineNumber--) {
+                    const line = lines[lineNumber];
+                    let match;
+                    while ((match = regex.exec(line)) !== null) {
+                        const startIndex = match.index;
+                        const pos = ( new Position(lineNumber + 1, startIndex + 1));
+                        if (!this.isPositionInRanges(pos, ignoredRanges)) {
+                            lastMatchOutsideIgnored = {
+                                line: lineNumber + 1,
+                                column: startIndex + 1
+                            };
+                            foundMatch = true;
+                            break;
+                        }
+                    }
+                    if (foundMatch) {
+                        break;
                     }
                 }
+                if (lastMatchOutsideIgnored) {
+                    const inlineVal = varName + ' = ' + vars.find(v => v.name === varName)?.value;
+                    let lineSegments = lineDecorations.get(lastMatchOutsideIgnored.line);
+                    if (!lineSegments) {
+                        lineSegments = [];
+                        lineDecorations.set(lastMatchOutsideIgnored.line, lineSegments);
+                    }
+                    if (!( lineSegments.some(iv => iv.text === inlineVal))) {
+                        lineSegments.push(( new InlineSegment(lastMatchOutsideIgnored.column, inlineVal)));
+                    }
+                }
+                processedVars.add(varName);
+            }
+            lineDecorations.forEach((segments, line) => {
+                if (segments.length > 0) {
+                    segments.sort((a, b) => a.column - b.column);
+                    const text = ( segments.map(s => s.text)).join(', ');
+                    const editorWidth = cell.layoutInfo.editorWidth;
+                    const fontInfo = cell.layoutInfo.fontInfo;
+                    if (fontInfo && cell.textModel) {
+                        const base = Math.floor((editorWidth - 50) / fontInfo.typicalHalfwidthCharacterWidth);
+                        const lineLength = cell.textModel.getLineLength(line);
+                        const available = Math.max(0, base - lineLength);
+                        inlineDecorations.push(...createInlineValueDecoration(line, text, 'nb', undefined, available));
+                    }
+                    else {
+                        inlineDecorations.push(...createInlineValueDecoration(line, text, 'nb'));
+                    }
+                }
+            });
+            if (inlineDecorations.length > 0) {
+                this.updateCellInlineDecorations(cell, inlineDecorations);
+                this.initCellContentListener(cell);
             }
         }
-        if (inlineDecorations.length > 0) {
-            this.updateCellInlineDecorations(cell, inlineDecorations);
-            this.initCellContentListener(cell);
+    }
+    getFunctionRanges(document) {
+        return document.getLanguageId() === 'python'
+            ? this.getPythonFunctionRanges(document.getValue())
+            : this.getBracedFunctionRanges(document.getValue());
+    }
+    getPythonFunctionRanges(code) {
+        const functionRanges = [];
+        const lines = code.split('\n');
+        let functionStartLine = -1;
+        let inFunction = false;
+        let pythonIndentLevel = -1;
+        const pythonFunctionDeclRegex = /^(\s*)(async\s+)?(?:def\s+\w+|class\s+\w+)\s*\([^)]*\)\s*:/;
+        for (let lineNumber = 0; lineNumber < lines.length; lineNumber++) {
+            const line = lines[lineNumber];
+            const pythonMatch = line.match(pythonFunctionDeclRegex);
+            if (pythonMatch) {
+                if (inFunction) {
+                    const currentIndent = pythonMatch[1].length;
+                    if (currentIndent <= pythonIndentLevel) {
+                        functionRanges.push(( new Range(functionStartLine + 1, 1, lineNumber, line.length + 1)));
+                        inFunction = false;
+                    }
+                }
+                if (!inFunction) {
+                    inFunction = true;
+                    functionStartLine = lineNumber;
+                    pythonIndentLevel = pythonMatch[1].length;
+                }
+                continue;
+            }
+            if (inFunction) {
+                if (line.trim() === '') {
+                    continue;
+                }
+                const currentIndent = line.match(/^\s*/)?.[0].length ?? 0;
+                if (currentIndent <= pythonIndentLevel) {
+                    functionRanges.push(( new Range(functionStartLine + 1, 1, lineNumber, line.length + 1)));
+                    inFunction = false;
+                    pythonIndentLevel = -1;
+                }
+            }
+        }
+        if (inFunction) {
+            functionRanges.push(( new Range(functionStartLine + 1, 1, lines.length, lines[lines.length - 1].length + 1)));
+        }
+        return functionRanges;
+    }
+    getBracedFunctionRanges(code) {
+        const functionRanges = [];
+        const lines = code.split('\n');
+        let braceDepth = 0;
+        let functionStartLine = -1;
+        let inFunction = false;
+        const functionDeclRegex = /\b(?:function\s+\w+|(?:async\s+)?(?:\w+\s*=\s*)?\([^)]*\)\s*=>|class\s+\w+|(?:public|private|protected|static)?\s*\w+\s*\([^)]*\)\s*{)/;
+        for (let lineNumber = 0; lineNumber < lines.length; lineNumber++) {
+            const line = lines[lineNumber];
+            for (const char of line) {
+                if (char === '{') {
+                    if (!inFunction && functionDeclRegex.test(line)) {
+                        inFunction = true;
+                        functionStartLine = lineNumber;
+                    }
+                    braceDepth++;
+                }
+                else if (char === '}') {
+                    braceDepth--;
+                    if (braceDepth === 0 && inFunction) {
+                        functionRanges.push(( new Range(functionStartLine + 1, 1, lineNumber + 1, line.length + 1)));
+                        inFunction = false;
+                    }
+                }
+            }
+        }
+        return functionRanges;
+    }
+    getCommentedRanges(document) {
+        return this._getCommentedRanges(document);
+    }
+    _getCommentedRanges(document) {
+        try {
+            return this.getCommentedRangesByAccurateTokenization(document);
+        }
+        catch (e) {
+            return this.getCommentedRangesByManualParsing(document);
+        }
+    }
+    getCommentedRangesByAccurateTokenization(document) {
+        const commentRanges = [];
+        const lineCount = document.getLineCount();
+        if (lineCount > NotebookInlineVariablesController_1.MAX_CELL_LINES) {
+            return commentRanges;
+        }
+        for (let lineNumber = 1; lineNumber <= lineCount; lineNumber++) {
+            if (!document.tokenization.hasAccurateTokensForLine(lineNumber)) {
+                document.tokenization.forceTokenization(lineNumber);
+            }
+            const lineTokens = document.tokenization.getLineTokens(lineNumber);
+            if (lineTokens.getCount() === 0) {
+                continue;
+            }
+            let startCharacter;
+            for (let tokenIndex = 0; tokenIndex < lineTokens.getCount(); tokenIndex++) {
+                const tokenType = lineTokens.getStandardTokenType(tokenIndex);
+                if (tokenType === StandardTokenType.Comment || tokenType === StandardTokenType.String || tokenType === StandardTokenType.RegEx) {
+                    if (startCharacter === undefined) {
+                        startCharacter = lineTokens.getStartOffset(tokenIndex);
+                    }
+                    const endCharacter = lineTokens.getEndOffset(tokenIndex);
+                    const isLastToken = tokenIndex === lineTokens.getCount() - 1;
+                    const nextTokenDifferent = !isLastToken &&
+                        lineTokens.getStandardTokenType(tokenIndex + 1) !== tokenType;
+                    if (isLastToken || nextTokenDifferent) {
+                        commentRanges.push(( new Range(lineNumber, startCharacter + 1, lineNumber, endCharacter + 1)));
+                        startCharacter = undefined;
+                    }
+                }
+                else {
+                    startCharacter = undefined;
+                }
+            }
+        }
+        return commentRanges;
+    }
+    getCommentedRangesByManualParsing(document) {
+        const commentRanges = [];
+        const lines = document.getValue().split('\n');
+        const languageId = document.getLanguageId();
+        const lineCommentToken = languageId === 'python' ? '#' :
+            languageId === 'javascript' || languageId === 'typescript' ? '//' :
+                null;
+        const blockComments = (languageId === 'javascript' || languageId === 'typescript') ? { start: '/*', end: '*/' } :
+            null;
+        let inBlockComment = false;
+        let blockCommentStartLine = -1;
+        let blockCommentStartCol = -1;
+        for (let lineNumber = 0; lineNumber < lines.length; lineNumber++) {
+            const line = lines[lineNumber];
+            const trimmedLine = line.trim();
+            if (trimmedLine.length === 0) {
+                continue;
+            }
+            if (blockComments) {
+                if (!inBlockComment) {
+                    const startIndex = line.indexOf(blockComments.start);
+                    if (startIndex !== -1) {
+                        inBlockComment = true;
+                        blockCommentStartLine = lineNumber;
+                        blockCommentStartCol = startIndex;
+                    }
+                }
+                if (inBlockComment) {
+                    const endIndex = line.indexOf(blockComments.end);
+                    if (endIndex !== -1) {
+                        commentRanges.push(( new Range(
+                            blockCommentStartLine + 1,
+                            blockCommentStartCol + 1,
+                            lineNumber + 1,
+                            endIndex + blockComments.end.length + 1
+                        )));
+                        inBlockComment = false;
+                    }
+                    continue;
+                }
+            }
+            if (!inBlockComment && lineCommentToken && line.trimLeft().startsWith(lineCommentToken)) {
+                const startCol = line.indexOf(lineCommentToken);
+                commentRanges.push(( new Range(lineNumber + 1, startCol + 1, lineNumber + 1, line.length + 1)));
+            }
         }
+        if (inBlockComment) {
+            commentRanges.push(( new Range(
+                blockCommentStartLine + 1,
+                blockCommentStartCol + 1,
+                lines.length,
+                lines[lines.length - 1].length + 1
+            )));
+        }
+        return commentRanges;
+    }
+    isPositionInRanges(position, ranges) {
+        return ( ranges.some(range => range.containsPosition(position)));
     }
     updateCellInlineDecorations(cell, decorations) {
         const oldDecorations = this.cellDecorationIds.get(cell) ?? [];
@@ -233,58 +487,16 @@ let NotebookInlineVariablesController = class NotebookInlineVariablesController
     clearNotebookInlineDecorations() {
         this._clearNotebookInlineDecorations();
     }
-    createNotebookInlineValueDecoration(lineNumber, contentText, column = Constants.MAX_SAFE_SMALL_INTEGER) {
-        if (contentText.length > MAX_INLINE_DECORATOR_LENGTH) {
-            contentText = contentText.substring(0, MAX_INLINE_DECORATOR_LENGTH) + '...';
-        }
-        return [
-            {
-                range: {
-                    startLineNumber: lineNumber,
-                    endLineNumber: lineNumber,
-                    startColumn: column,
-                    endColumn: column
-                },
-                options: {
-                    description: 'nb-inline-value-decoration-spacer',
-                    after: {
-                        content: noBreakWhitespace,
-                        cursorStops: InjectedTextCursorStops.None
-                    },
-                    showIfCollapsed: true,
-                }
-            },
-            {
-                range: {
-                    startLineNumber: lineNumber,
-                    endLineNumber: lineNumber,
-                    startColumn: column,
-                    endColumn: column
-                },
-                options: {
-                    description: 'nb-inline-value-decoration',
-                    after: {
-                        content: this.replaceWsWithNoBreakWs(contentText),
-                        inlineClassName: 'nb-inline-value',
-                        inlineClassNameAffectsLetterSpacing: true,
-                        cursorStops: InjectedTextCursorStops.None
-                    },
-                    showIfCollapsed: true,
-                }
-            },
-        ];
-    }
-    replaceWsWithNoBreakWs(str) {
-        return str.replace(/[ \t]/g, noBreakWhitespace);
-    }
     dispose() {
         super.dispose();
         this._clearNotebookInlineDecorations();
         this.currentCancellationTokenSources.forEach(source => source.cancel());
         this.currentCancellationTokenSources.clear();
+        this.cellContentListeners.forEach(listener => listener.dispose());
+        this.cellContentListeners.clear();
     }
 };
-NotebookInlineVariablesController = ( __decorate([
+NotebookInlineVariablesController = NotebookInlineVariablesController_1 = ( __decorate([
     ( __param(1, INotebookKernelService)),
     ( __param(2, INotebookExecutionStateService)),
     ( __param(3, ILanguageFeaturesService)),
@@ -296,7 +508,7 @@ registerAction2(class ClearNotebookInlineValues extends NotebookAction {
     constructor() {
         super({
             id: 'notebook.clearAllInlineValues',
-            title: ( localize(7538, 'Clear All Inline Values')),
+            title: ( localize(7623, 'Clear All Inline Values')),
         });
     }
     runWithContext(accessor, context) {

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariables.js

@@ -11,8 +11,8 @@ import { IViewDescriptorService } from '@codingame/monaco-vscode-api/vscode/vs/w
 import { VIEWLET_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/debug/common/debug';
 import { NOTEBOOK_VARIABLE_VIEW_ENABLED } from './notebookVariableContextKeys.js';
 import { NotebookVariablesView } from './notebookVariablesView.js';
-import { getNotebookEditorFromEditorPane } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
-import { variablesViewIcon } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/browser/notebookIcons';
+import { getNotebookEditorFromEditorPane } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { variablesViewIcon } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/notebook/browser/notebookIcons';
 import { NotebookSetting } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
 import { INotebookExecutionStateService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService.service';
 import { INotebookKernelService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookKernelService.service';
@@ -63,7 +63,7 @@ let NotebookVariables = class NotebookVariables extends Disposable {
         if (debugViewContainer) {
             const viewsRegistry = ( Registry.as(Extensions.ViewsRegistry));
             const viewDescriptor = {
-                id: 'workbench.notebook.variables', name: ( localize2(7541, "Notebook Variables")),
+                id: 'workbench.notebook.variables', name: ( localize2(7626, "Notebook Variables")),
                 containerIcon: variablesViewIcon, ctorDescriptor: ( new SyncDescriptor(NotebookVariablesView)),
                 order: 50, weight: 5, canToggleVisibility: true, canMoveView: true, collapsed: false, when: NOTEBOOK_VARIABLE_VIEW_ENABLED
             };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariablesDataSource.js

@@ -78,7 +78,7 @@ class NotebookVariableDataSource {
                     notebook: parent.notebook,
                     id: parent.id + `${last + 1}`,
                     extHostId: parent.extHostId,
-                    name: ( localize(7542, "Display limit reached")),
+                    name: ( localize(7627, "Display limit reached")),
                     value: '',
                     indexedChildrenCount: 0,
                     hasNamedChildren: false

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariablesTree.js

@@ -56,10 +56,10 @@ NotebookVariableRenderer = NotebookVariableRenderer_1 = ( __decorate([
 ], NotebookVariableRenderer));
 class NotebookVariableAccessibilityProvider {
     getWidgetAriaLabel() {
-        return localize(7543, "Notebook Variables");
+        return localize(7628, "Notebook Variables");
     }
     getAriaLabel(element) {
-        return localize(7544, "Variable {0}, value {1}", element.name, element.value);
+        return localize(7629, "Variable {0}, value {1}", element.name, element.value);
     }
 }
 

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariablesView.d.ts

@@ -9,7 +9,6 @@ import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/pl
 import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
 import { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
 import { IQuickInputService } from "@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service";
-import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
 import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
 import { IViewPaneOptions, ViewPane } from "@codingame/monaco-vscode-65619f8f-0eab-5d8b-855a-43b6353fe527-common/vscode/vs/workbench/browser/parts/views/viewPane";
 import { IViewDescriptorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/views.service";
@@ -39,7 +38,7 @@ export declare class NotebookVariablesView extends ViewPane {
     private activeNotebook;
     private readonly dataSource;
     private updateScheduler;
-    constructor(options: IViewPaneOptions, editorService: IEditorService, notebookKernelService: INotebookKernelService, notebookExecutionStateService: INotebookExecutionStateService, keybindingService: IKeybindingService, contextMenuService: IContextMenuService, contextKeyService: IContextKeyService, configurationService: IConfigurationService, instantiationService: IInstantiationService, viewDescriptorService: IViewDescriptorService, openerService: IOpenerService, quickInputService: IQuickInputService, commandService: ICommandService, themeService: IThemeService, telemetryService: ITelemetryService, hoverService: IHoverService, menuService: IMenuService);
+    constructor(options: IViewPaneOptions, editorService: IEditorService, notebookKernelService: INotebookKernelService, notebookExecutionStateService: INotebookExecutionStateService, keybindingService: IKeybindingService, contextMenuService: IContextMenuService, contextKeyService: IContextKeyService, configurationService: IConfigurationService, instantiationService: IInstantiationService, viewDescriptorService: IViewDescriptorService, openerService: IOpenerService, quickInputService: IQuickInputService, commandService: ICommandService, themeService: IThemeService, hoverService: IHoverService, menuService: IMenuService);
     protected renderBody(container: HTMLElement): void;
     private onContextMenu;
     focus(): void;