@codingame/monaco-vscode-api 8.0.3 → 9.0.0

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/view/conflictActions.js

@@ -0,0 +1,269 @@
+import { createStyleSheet, isInShadowDOM, h, $, reset } from '../../../../../base/browser/dom.js';
+import { renderLabelWithIcons } from '../../../../../base/browser/ui/iconLabel/iconLabels.js';
+import { hash } from '../../../../../base/common/hash.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+import { transaction } from '../../../../../base/common/observableInternal/base.js';
+import { derived } from '../../../../../base/common/observableInternal/derived.js';
+import { autorun } from '../../../../../base/common/observableInternal/autorun.js';
+import '../../../../../base/common/observableInternal/utils.js';
+import '../../../../../base/common/cancellation.js';
+import '../../../../../base/common/arrays.js';
+import { EditorOption, EDITOR_FONT_DEFAULTS } from '../../../../../editor/common/config/editorOptions.js';
+import { localize } from '../../../../../nls.js';
+import { ModifiedBaseRangeStateKind, ModifiedBaseRangeState } from '../model/modifiedBaseRange.js';
+import { FixedZoneWidget } from './fixedZoneWidget.js';
+class ConflictActionsFactory extends Disposable {
+    constructor(_editor) {
+        super();
+        this._editor = _editor;
+        this._register(this._editor.onDidChangeConfiguration((e) => {
+            if (e.hasChanged(EditorOption.fontInfo) || e.hasChanged(EditorOption.codeLensFontSize) || e.hasChanged(EditorOption.codeLensFontFamily)) {
+                this._updateLensStyle();
+            }
+        }));
+        this._styleClassName = '_conflictActionsFactory_' + ( (hash(this._editor.getId()).toString(16)));
+        this._styleElement = createStyleSheet(isInShadowDOM(this._editor.getContainerDomNode())
+            ? this._editor.getContainerDomNode()
+            : undefined, undefined, this._store);
+        this._updateLensStyle();
+    }
+    _updateLensStyle() {
+        const { codeLensHeight, fontSize } = this._getLayoutInfo();
+        const fontFamily = this._editor.getOption(EditorOption.codeLensFontFamily);
+        const editorFontInfo = this._editor.getOption(EditorOption.fontInfo);
+        const fontFamilyVar = `--codelens-font-family${this._styleClassName}`;
+        const fontFeaturesVar = `--codelens-font-features${this._styleClassName}`;
+        let newStyle = `
+		.${this._styleClassName} { line-height: ${codeLensHeight}px; font-size: ${fontSize}px; padding-right: ${Math.round(fontSize * 0.5)}px; font-feature-settings: var(${fontFeaturesVar}) }
+		.monaco-workbench .${this._styleClassName} span.codicon { line-height: ${codeLensHeight}px; font-size: ${fontSize}px; }
+		`;
+        if (fontFamily) {
+            newStyle += `${this._styleClassName} { font-family: var(${fontFamilyVar}), ${EDITOR_FONT_DEFAULTS.fontFamily}}`;
+        }
+        this._styleElement.textContent = newStyle;
+        this._editor.getContainerDomNode().style?.setProperty(fontFamilyVar, fontFamily ?? 'inherit');
+        this._editor.getContainerDomNode().style?.setProperty(fontFeaturesVar, editorFontInfo.fontFeatureSettings);
+    }
+    _getLayoutInfo() {
+        const lineHeightFactor = Math.max(1.3, this._editor.getOption(EditorOption.lineHeight) / this._editor.getOption(EditorOption.fontSize));
+        let fontSize = this._editor.getOption(EditorOption.codeLensFontSize);
+        if (!fontSize || fontSize < 5) {
+            fontSize = (this._editor.getOption(EditorOption.fontSize) * .9) | 0;
+        }
+        return {
+            fontSize,
+            codeLensHeight: (fontSize * lineHeightFactor) | 0,
+        };
+    }
+    createWidget(viewZoneChangeAccessor, lineNumber, items, viewZoneIdsToCleanUp) {
+        const layoutInfo = this._getLayoutInfo();
+        return (
+             (new ActionsContentWidget(
+                this._editor,
+                viewZoneChangeAccessor,
+                lineNumber,
+                layoutInfo.codeLensHeight + 2,
+                this._styleClassName,
+                items,
+                viewZoneIdsToCleanUp
+            ))
+        );
+    }
+}
+class ActionsSource {
+    constructor(viewModel, modifiedBaseRange) {
+        this.viewModel = viewModel;
+        this.modifiedBaseRange = modifiedBaseRange;
+        this.itemsInput1 = this.getItemsInput(1);
+        this.itemsInput2 = this.getItemsInput(2);
+        this.resultItems = derived(this, reader => {
+            const viewModel = this.viewModel;
+            const modifiedBaseRange = this.modifiedBaseRange;
+            const state = viewModel.model.getState(modifiedBaseRange).read(reader);
+            const model = viewModel.model;
+            const result = [];
+            if (state.kind === ModifiedBaseRangeStateKind.unrecognized) {
+                result.push({
+                    text: ( localize(11438, "Manual Resolution")),
+                    tooltip: ( localize(11439, "This conflict has been resolved manually.")),
+                });
+            }
+            else if (state.kind === ModifiedBaseRangeStateKind.base) {
+                result.push({
+                    text: ( localize(11440, 'No Changes Accepted')),
+                    tooltip: ( localize(
+                        11441,
+                        'The current resolution of this conflict equals the common ancestor of both the right and left changes.'
+                    )),
+                });
+            }
+            else {
+                const labels = [];
+                if (state.includesInput1) {
+                    labels.push(model.input1.title);
+                }
+                if (state.includesInput2) {
+                    labels.push(model.input2.title);
+                }
+                if (state.kind === ModifiedBaseRangeStateKind.both && state.firstInput === 2) {
+                    labels.reverse();
+                }
+                result.push({
+                    text: `${labels.join(' + ')}`
+                });
+            }
+            const stateToggles = [];
+            if (state.includesInput1) {
+                stateToggles.push(command(( localize(11442, 'Remove {0}', model.input1.title)), async () => {
+                    transaction((tx) => {
+                        model.setState(modifiedBaseRange, state.withInputValue(1, false), true, tx);
+                        model.telemetry.reportRemoveInvoked(1, state.includesInput(2));
+                    });
+                }, ( localize(11443, 'Remove {0} from the result document.', model.input1.title))));
+            }
+            if (state.includesInput2) {
+                stateToggles.push(command(( localize(11442, 'Remove {0}', model.input2.title)), async () => {
+                    transaction((tx) => {
+                        model.setState(modifiedBaseRange, state.withInputValue(2, false), true, tx);
+                        model.telemetry.reportRemoveInvoked(2, state.includesInput(1));
+                    });
+                }, ( localize(11443, 'Remove {0} from the result document.', model.input2.title))));
+            }
+            if (state.kind === ModifiedBaseRangeStateKind.both &&
+                state.firstInput === 2) {
+                stateToggles.reverse();
+            }
+            result.push(...stateToggles);
+            if (state.kind === ModifiedBaseRangeStateKind.unrecognized) {
+                result.push(command(( localize(11444, 'Reset to base')), async () => {
+                    transaction((tx) => {
+                        model.setState(modifiedBaseRange, ModifiedBaseRangeState.base, true, tx);
+                        model.telemetry.reportResetToBaseInvoked();
+                    });
+                }, ( localize(
+                    11445,
+                    'Reset this conflict to the common ancestor of both the right and left changes.'
+                ))));
+            }
+            return result;
+        });
+        this.isEmpty = derived(this, reader => {
+            return this.itemsInput1.read(reader).length + this.itemsInput2.read(reader).length + this.resultItems.read(reader).length === 0;
+        });
+        this.inputIsEmpty = derived(this, reader => {
+            return this.itemsInput1.read(reader).length + this.itemsInput2.read(reader).length === 0;
+        });
+    }
+    getItemsInput(inputNumber) {
+        return derived(reader => {
+            const viewModel = this.viewModel;
+            const modifiedBaseRange = this.modifiedBaseRange;
+            if (!viewModel.model.hasBaseRange(modifiedBaseRange)) {
+                return [];
+            }
+            const state = viewModel.model.getState(modifiedBaseRange).read(reader);
+            const handled = viewModel.model.isHandled(modifiedBaseRange).read(reader);
+            const model = viewModel.model;
+            const result = [];
+            const inputData = inputNumber === 1 ? viewModel.model.input1 : viewModel.model.input2;
+            const showNonConflictingChanges = viewModel.showNonConflictingChanges.read(reader);
+            if (!modifiedBaseRange.isConflicting && handled && !showNonConflictingChanges) {
+                return [];
+            }
+            const otherInputNumber = inputNumber === 1 ? 2 : 1;
+            if (state.kind !== ModifiedBaseRangeStateKind.unrecognized && !state.isInputIncluded(inputNumber)) {
+                if (!state.isInputIncluded(otherInputNumber) || !this.viewModel.shouldUseAppendInsteadOfAccept.read(reader)) {
+                    result.push(command(( localize(11446, "Accept {0}", inputData.title)), async () => {
+                        transaction((tx) => {
+                            model.setState(modifiedBaseRange, state.withInputValue(inputNumber, true, false), inputNumber, tx);
+                            model.telemetry.reportAcceptInvoked(inputNumber, state.includesInput(otherInputNumber));
+                        });
+                    }, ( localize(11447, "Accept {0} in the result document.", inputData.title))));
+                    if (modifiedBaseRange.canBeCombined) {
+                        const commandName = modifiedBaseRange.isOrderRelevant
+                            ? ( localize(11448, "Accept Combination ({0} First)", inputData.title))
+                            : ( localize(11449, "Accept Combination"));
+                        result.push(command(commandName, async () => {
+                            transaction((tx) => {
+                                model.setState(modifiedBaseRange, ModifiedBaseRangeState.base
+                                    .withInputValue(inputNumber, true)
+                                    .withInputValue(otherInputNumber, true, true), true, tx);
+                                model.telemetry.reportSmartCombinationInvoked(state.includesInput(otherInputNumber));
+                            });
+                        }, ( localize(
+                            11450,
+                            "Accept an automatic combination of both sides in the result document."
+                        ))));
+                    }
+                }
+                else {
+                    result.push(command(( localize(11451, "Append {0}", inputData.title)), async () => {
+                        transaction((tx) => {
+                            model.setState(modifiedBaseRange, state.withInputValue(inputNumber, true, false), inputNumber, tx);
+                            model.telemetry.reportAcceptInvoked(inputNumber, state.includesInput(otherInputNumber));
+                        });
+                    }, ( localize(11452, "Append {0} to the result document.", inputData.title))));
+                    if (modifiedBaseRange.canBeCombined) {
+                        result.push(command(( localize(11453, "Accept Combination", inputData.title)), async () => {
+                            transaction((tx) => {
+                                model.setState(modifiedBaseRange, state.withInputValue(inputNumber, true, true), inputNumber, tx);
+                                model.telemetry.reportSmartCombinationInvoked(state.includesInput(otherInputNumber));
+                            });
+                        }, ( localize(
+                            11450,
+                            "Accept an automatic combination of both sides in the result document."
+                        ))));
+                    }
+                }
+                if (!model.isInputHandled(modifiedBaseRange, inputNumber).read(reader)) {
+                    result.push(command(( localize(11454, 'Ignore')), async () => {
+                        transaction((tx) => {
+                            model.setInputHandled(modifiedBaseRange, inputNumber, true, tx);
+                        });
+                    }, ( localize(11455, "Don't take this side of the conflict."))));
+                }
+            }
+            return result;
+        });
+    }
+}
+function command(title, action, tooltip) {
+    return {
+        text: title,
+        action,
+        tooltip,
+    };
+}
+class ActionsContentWidget extends FixedZoneWidget {
+    constructor(editor, viewZoneAccessor, afterLineNumber, height, className, items, viewZoneIdsToCleanUp) {
+        super(editor, viewZoneAccessor, afterLineNumber, height, viewZoneIdsToCleanUp);
+        this._domNode = h('div.merge-editor-conflict-actions').root;
+        this.widgetDomNode.appendChild(this._domNode);
+        this._domNode.classList.add(className);
+        this._register(autorun(reader => {
+            const i = items.read(reader);
+            this.setState(i);
+        }));
+    }
+    setState(items) {
+        const children = [];
+        let isFirst = true;
+        for (const item of items) {
+            if (isFirst) {
+                isFirst = false;
+            }
+            else {
+                children.push($('span', undefined, '\u00a0|\u00a0'));
+            }
+            const title = renderLabelWithIcons(item.text);
+            if (item.action) {
+                children.push($('a', { title: item.tooltip, role: 'button', onclick: () => item.action() }, ...title));
+            }
+            else {
+                children.push($('span', { title: item.tooltip }, ...title));
+            }
+        }
+        reset(this._domNode, ...children);
+    }
+}
+export { ActionsSource, ConflictActionsFactory };

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/view/fixedZoneWidget.js

@@ -0,0 +1,40 @@
+import { h } from '../../../../../base/browser/dom.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+import { Event } from '../../../../../base/common/event.js';
+class FixedZoneWidget extends Disposable {
+    static { this.counter = 0; }
+    constructor(editor, viewZoneAccessor, afterLineNumber, height, viewZoneIdsToCleanUp) {
+        super();
+        this.editor = editor;
+        this.overlayWidgetId = `fixedZoneWidget-${FixedZoneWidget.counter++}`;
+        this.widgetDomNode = h('div.fixed-zone-widget').root;
+        this.overlayWidget = {
+            getId: () => this.overlayWidgetId,
+            getDomNode: () => this.widgetDomNode,
+            getPosition: () => null
+        };
+        this.viewZoneId = viewZoneAccessor.addZone({
+            domNode: document.createElement('div'),
+            afterLineNumber: afterLineNumber,
+            heightInPx: height,
+            ordinal: 50000 + 1,
+            onComputedHeight: (height) => {
+                this.widgetDomNode.style.height = `${height}px`;
+            },
+            onDomNodeTop: (top) => {
+                this.widgetDomNode.style.top = `${top}px`;
+            }
+        });
+        viewZoneIdsToCleanUp.push(this.viewZoneId);
+        this._register(Event.runAndSubscribe(this.editor.onDidLayoutChange, () => {
+            this.widgetDomNode.style.left = this.editor.getLayoutInfo().contentLeft + 'px';
+        }));
+        this.editor.addOverlayWidget(this.overlayWidget);
+        this._register({
+            dispose: () => {
+                this.editor.removeOverlayWidget(this.overlayWidget);
+            },
+        });
+    }
+}
+export { FixedZoneWidget };

package/vscode/src/vs/workbench/contrib/mergeEditor/common/mergeEditor.js

@@ -1,32 +1,32 @@
 import { localize } from '../../../../nls.js';
 import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
-const ctxIsMergeEditor = ( (new RawContextKey('isMergeEditor', false, { type: 'boolean', description: ( localize(10824, 'The editor is a merge editor')) })));
+const ctxIsMergeEditor = ( (new RawContextKey('isMergeEditor', false, { type: 'boolean', description: ( localize(10843, 'The editor is a merge editor')) })));
 const ctxIsMergeResultEditor = ( (new RawContextKey(
  'isMergeResultEditor',
  false,
- { type: 'boolean', description: ( localize(10825, 'The editor is a the result editor of a merge editor.')) }
+ { type: 'boolean', description: ( localize(10844, 'The editor is a the result editor of a merge editor.')) }
 )));
 const ctxMergeEditorLayout = ( (new RawContextKey(
  'mergeEditorLayout',
  'mixed',
- { type: 'string', description: ( localize(10826, 'The layout mode of a merge editor')) }
+ { type: 'string', description: ( localize(10845, 'The layout mode of a merge editor')) }
 )));
 const ctxMergeEditorShowBase = ( (new RawContextKey(
  'mergeEditorShowBase',
  false,
- { type: 'boolean', description: ( localize(10827, 'If the merge editor shows the base version')) }
+ { type: 'boolean', description: ( localize(10846, 'If the merge editor shows the base version')) }
 )));
 const ctxMergeEditorShowBaseAtTop = ( (new RawContextKey(
  'mergeEditorShowBaseAtTop',
  false,
- { type: 'boolean', description: ( localize(10828, 'If base should be shown at the top')) }
+ { type: 'boolean', description: ( localize(10847, 'If base should be shown at the top')) }
 )));
 const ctxMergeEditorShowNonConflictingChanges = ( (new RawContextKey(
  'mergeEditorShowNonConflictingChanges',
  false,
- { type: 'boolean', description: ( localize(10829, 'If the merge editor shows non-conflicting changes')) }
+ { type: 'boolean', description: ( localize(10848, 'If the merge editor shows non-conflicting changes')) }
 )));
-const ctxMergeBaseUri = ( (new RawContextKey('mergeEditorBaseUri', '', { type: 'string', description: ( localize(10830, 'The uri of the baser of a merge editor')) })));
-const ctxMergeResultUri = ( (new RawContextKey('mergeEditorResultUri', '', { type: 'string', description: ( localize(10831, 'The uri of the result of a merge editor')) })));
+const ctxMergeBaseUri = ( (new RawContextKey('mergeEditorBaseUri', '', { type: 'string', description: ( localize(10849, 'The uri of the baser of a merge editor')) })));
+const ctxMergeResultUri = ( (new RawContextKey('mergeEditorResultUri', '', { type: 'string', description: ( localize(10850, 'The uri of the result of a merge editor')) })));
 const StorageCloseWithConflicts = 'mergeEditorCloseWithConflicts';
 export { StorageCloseWithConflicts, ctxIsMergeEditor, ctxIsMergeResultEditor, ctxMergeBaseUri, ctxMergeEditorLayout, ctxMergeEditorShowBase, ctxMergeEditorShowBaseAtTop, ctxMergeEditorShowNonConflictingChanges, ctxMergeResultUri };

package/vscode/src/vs/workbench/contrib/multiDiffEditor/browser/icons.contribution.js

@@ -1,5 +1,5 @@
 import { Codicon } from '../../../../base/common/codicons.js';
 import { localize } from '../../../../nls.js';
 import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';
-const MultiDiffEditorIcon = registerIcon('multi-diff-editor-label-icon', Codicon.diffMultiple, ( localize(10264, 'Icon of the multi diff editor label.')));
+const MultiDiffEditorIcon = registerIcon('multi-diff-editor-label-icon', Codicon.diffMultiple, ( localize(10296, 'Icon of the multi diff editor label.')));
 export { MultiDiffEditorIcon };

package/vscode/src/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput.js

@@ -93,9 +93,14 @@ let MultiDiffEditorInput = class MultiDiffEditorInput extends EditorInput {
             };
         })));
         this.resources = derived(this, reader => this._resolvedSource.cachedPromiseResult.read(reader)?.data?.resources.read(reader));
+        this.textFileServiceOnDidChange = ( (new FastEventDispatcher(
+            this._textFileService.files.onDidChangeDirty,
+            item => ( (item.resource.toString())),
+            uri => ( (uri.toString()))
+        )));
         this._isDirtyObservables = mapObservableArrayCached(this, ( (this.resources.map(r => r ?? []))), res => {
-            const isModifiedDirty = res.modifiedUri ? isUriDirty(this._textFileService, res.modifiedUri) : constObservable(false);
-            const isOriginalDirty = res.originalUri ? isUriDirty(this._textFileService, res.originalUri) : constObservable(false);
+            const isModifiedDirty = res.modifiedUri ? isUriDirty(this.textFileServiceOnDidChange, this._textFileService, res.modifiedUri) : constObservable(false);
+            const isOriginalDirty = res.originalUri ? isUriDirty(this.textFileServiceOnDidChange, this._textFileService, res.originalUri) : constObservable(false);
             return derived(reader =>  isModifiedDirty.read(reader) || isOriginalDirty.read(reader));
         }, i => i.getKey());
         this._isDirtyObservable = derived(this, reader => ( (this._isDirtyObservables.read(reader).some(isDirty => isDirty.read(reader)))))
@@ -111,9 +116,9 @@ let MultiDiffEditorInput = class MultiDiffEditorInput extends EditorInput {
         };
         this._register(autorun((reader) => {
             const resources = this.resources.read(reader);
-            const label = this.label ?? ( localize(6141, "Multi Diff Editor"));
+            const label = this.label ?? ( localize(6083, "Multi Diff Editor"));
             if (resources) {
-                this._name = label + ( localize(6142, " ({0} files)", resources.length));
+                this._name = label + ( localize(6084, " ({0} files)", resources.length));
             }
             else {
                 this._name = label;
@@ -176,6 +181,7 @@ let MultiDiffEditorInput = class MultiDiffEditorInput extends EditorInput {
                 multiDiffEditorItem: r,
                 original: original?.object.textEditorModel,
                 modified: modified?.object.textEditorModel,
+                contextKeys: r.contextKeys,
                 get options() {
                     return {
                         ...getReadonlyConfiguration(modified?.object.isReadonly() ?? true),
@@ -245,8 +251,54 @@ MultiDiffEditorInput = MultiDiffEditorInput_1 = ( (__decorate([
     ( (__param(7, IMultiDiffSourceResolverService))),
     ( (__param(8, ITextFileService)))
 ], MultiDiffEditorInput)));
-function isUriDirty(textFileService, uri) {
-    return observableFromEvent(Event.filter(textFileService.files.onDidChangeDirty, e => ( (e.resource.toString())) === ( (uri.toString()))), () => textFileService.isDirty(uri));
+class FastEventDispatcher {
+    constructor(_event, _getEventArgsKey, _keyToString) {
+        this._event = _event;
+        this._getEventArgsKey = _getEventArgsKey;
+        this._keyToString = _keyToString;
+        this._count = 0;
+        this._buckets = ( (new Map()));
+        this._handleEventChange = (e) => {
+            const key = this._getEventArgsKey(e);
+            const bucket = this._buckets.get(key);
+            if (bucket) {
+                for (const listener of bucket) {
+                    listener(e);
+                }
+            }
+        };
+    }
+    filteredEvent(filter) {
+        return listener => {
+            const key = this._keyToString(filter);
+            let bucket = this._buckets.get(key);
+            if (!bucket) {
+                bucket = ( (new Set()));
+                this._buckets.set(key, bucket);
+            }
+            bucket.add(listener);
+            this._count++;
+            if (this._count === 1) {
+                this._eventSubscription = this._event(this._handleEventChange);
+            }
+            return {
+                dispose: () => {
+                    bucket.delete(listener);
+                    if (bucket.size === 0) {
+                        this._buckets.delete(key);
+                    }
+                    this._count--;
+                    if (this._count === 0) {
+                        this._eventSubscription?.dispose();
+                        this._eventSubscription = undefined;
+                    }
+                }
+            };
+        };
+    }
+}
+function isUriDirty(onDidChangeDirty, textFileService, uri) {
+    return observableFromEvent(onDidChangeDirty.filteredEvent(uri), () => textFileService.isDirty(uri));
 }
 function getReadonlyConfiguration(isReadonly) {
     return {

package/vscode/src/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService.js

@@ -1,10 +1,11 @@
 import { BugIndicatingError } from '../../../../base/common/errors.js';
 import { toDisposable } from '../../../../base/common/lifecycle.js';
 class MultiDiffEditorItem {
-    constructor(originalUri, modifiedUri, goToFileUri) {
+    constructor(originalUri, modifiedUri, goToFileUri, contextKeys) {
         this.originalUri = originalUri;
         this.modifiedUri = modifiedUri;
         this.goToFileUri = goToFileUri;
+        this.contextKeys = contextKeys;
         if (!originalUri && !modifiedUri) {
             throw ( new BugIndicatingError('Invalid arguments'));
         }

package/vscode/src/vs/workbench/contrib/multiDiffEditor/browser/scmMultiDiffSourceResolver.js

@@ -99,7 +99,7 @@ class OpenScmGroupAction extends Action2 {
     constructor() {
         super({
             id: '_workbench.openScmMultiDiffEditor',
-            title: ( localize2(6146, 'View Changes')),
+            title: ( localize2(6088, 'View Changes')),
             f1: false
         });
     }

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/cellStatusBar/executionStatusBarItemController.js

@@ -132,7 +132,7 @@ let ExecutionStateCellStatusBarItem = class ExecutionStateCellStatusBarItem exte
             return [{
                     text: `$(${successStateIcon.id})`,
                     color: themeColorFromId(cellStatusIconSuccess),
-                    tooltip: ( localize(7976, "Success")),
+                    tooltip: ( localize(8220, "Success")),
                     alignment: CellStatusbarAlignment.Left,
                     priority: Number.MAX_SAFE_INTEGER
                 }];
@@ -141,7 +141,7 @@ let ExecutionStateCellStatusBarItem = class ExecutionStateCellStatusBarItem exte
             return [{
                     text: `$(${errorStateIcon.id})`,
                     color: themeColorFromId(cellStatusIconError),
-                    tooltip: ( localize(7977, "Failed")),
+                    tooltip: ( localize(8221, "Failed")),
                     alignment: CellStatusbarAlignment.Left,
                     priority: Number.MAX_SAFE_INTEGER
                 }];
@@ -149,7 +149,7 @@ let ExecutionStateCellStatusBarItem = class ExecutionStateCellStatusBarItem exte
         else if (state === NotebookCellExecutionState.Pending || state === NotebookCellExecutionState.Unconfirmed) {
             return [{
                     text: `$(${pendingStateIcon.id})`,
-                    tooltip: ( localize(7978, "Pending")),
+                    tooltip: ( localize(8222, "Pending")),
                     alignment: CellStatusbarAlignment.Left,
                     priority: Number.MAX_SAFE_INTEGER
                 }];
@@ -160,7 +160,7 @@ let ExecutionStateCellStatusBarItem = class ExecutionStateCellStatusBarItem exte
                 ThemeIcon.modify(executingStateIcon, 'spin');
             return [{
                     text: `$(${icon.id})`,
-                    tooltip: ( localize(7979, "Executing")),
+                    tooltip: ( localize(8223, "Executing")),
                     alignment: CellStatusbarAlignment.Left,
                     priority: Number.MAX_SAFE_INTEGER
                 }];
@@ -264,10 +264,10 @@ let TimerCellStatusBarItem = class TimerCellStatusBarItem extends Disposable {
                 }));
                 renderTimes += `- [${rendererInfo?.displayName ?? key}](command:workbench.action.openIssueReporter?${args}) ${formatCellDuration(renderDuration[key])}\n`;
             }
-            renderTimes += `\n*${( localize(7980, "Use the links above to file an issue using the issue reporter."))}*\n`;
+            renderTimes += `\n*${( localize(8224, "Use the links above to file an issue using the issue reporter."))}*\n`;
             tooltip = {
                 value: ( localize(
-                    7981,
+                    8225,
                     "**Last Execution** {0}\n\n**Execution Time** {1}\n\n**Overhead Time** {2}\n\n**Render Times**\n\n{3}",
                     lastExecution,
                     formatCellDuration(executionDuration),

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/find/notebookFindReplaceWidget.js

@@ -44,23 +44,23 @@ import { registerThemingParticipant } from '../../../../../../platform/theme/com
 import { filterIcon } from '../../../../extensions/browser/extensionsIcons.js';
 import { NotebookFindFilters } from './findFilters.js';
 import { NotebookSetting, NotebookFindScopeType } from '../../../common/notebookCommon.js';
-const NLS_FIND_INPUT_LABEL = ( localize(11274, "Find"));
-const NLS_FIND_INPUT_PLACEHOLDER = ( localize(11275, "Find"));
-const NLS_PREVIOUS_MATCH_BTN_LABEL = ( localize(11276, "Previous Match"));
-const NLS_NEXT_MATCH_BTN_LABEL = ( localize(11277, "Next Match"));
-const NLS_TOGGLE_SELECTION_FIND_TITLE = ( localize(11278, "Find in Selection"));
-const NLS_CLOSE_BTN_LABEL = ( localize(11279, "Close"));
-const NLS_TOGGLE_REPLACE_MODE_BTN_LABEL = ( localize(11280, "Toggle Replace"));
-const NLS_REPLACE_INPUT_LABEL = ( localize(11281, "Replace"));
-const NLS_REPLACE_INPUT_PLACEHOLDER = ( localize(11282, "Replace"));
-const NLS_REPLACE_BTN_LABEL = ( localize(11283, "Replace"));
-const NLS_REPLACE_ALL_BTN_LABEL = ( localize(11284, "Replace All"));
-registerIcon('find-filter', Codicon.filter, ( localize(11285, 'Icon for Find Filter in find widget.')));
-const NOTEBOOK_FIND_FILTERS = ( localize(11286, "Find Filters"));
-const NOTEBOOK_FIND_IN_MARKUP_INPUT = ( localize(11287, "Markdown Source"));
-const NOTEBOOK_FIND_IN_MARKUP_PREVIEW = ( localize(11288, "Rendered Markdown"));
-const NOTEBOOK_FIND_IN_CODE_INPUT = ( localize(11289, "Code Cell Source"));
-const NOTEBOOK_FIND_IN_CODE_OUTPUT = ( localize(11290, "Code Cell Output"));
+const NLS_FIND_INPUT_LABEL = ( localize(11335, "Find"));
+const NLS_FIND_INPUT_PLACEHOLDER = ( localize(11336, "Find"));
+const NLS_PREVIOUS_MATCH_BTN_LABEL = ( localize(11337, "Previous Match"));
+const NLS_NEXT_MATCH_BTN_LABEL = ( localize(11338, "Next Match"));
+const NLS_TOGGLE_SELECTION_FIND_TITLE = ( localize(11339, "Find in Selection"));
+const NLS_CLOSE_BTN_LABEL = ( localize(11340, "Close"));
+const NLS_TOGGLE_REPLACE_MODE_BTN_LABEL = ( localize(11341, "Toggle Replace"));
+const NLS_REPLACE_INPUT_LABEL = ( localize(11342, "Replace"));
+const NLS_REPLACE_INPUT_PLACEHOLDER = ( localize(11343, "Replace"));
+const NLS_REPLACE_BTN_LABEL = ( localize(11344, "Replace"));
+const NLS_REPLACE_ALL_BTN_LABEL = ( localize(11345, "Replace All"));
+registerIcon('find-filter', Codicon.filter, ( localize(11346, 'Icon for Find Filter in find widget.')));
+const NOTEBOOK_FIND_FILTERS = ( localize(11347, "Find Filters"));
+const NOTEBOOK_FIND_IN_MARKUP_INPUT = ( localize(11348, "Markdown Source"));
+const NOTEBOOK_FIND_IN_MARKUP_PREVIEW = ( localize(11349, "Rendered Markdown"));
+const NOTEBOOK_FIND_IN_CODE_INPUT = ( localize(11350, "Code Cell Source"));
+const NOTEBOOK_FIND_IN_CODE_OUTPUT = ( localize(11351, "Code Cell Output"));
 const NOTEBOOK_FIND_WIDGET_INITIAL_WIDTH = 419;
 const NOTEBOOK_FIND_WIDGET_INITIAL_HORIZONTAL_PADDING = 4;
 let NotebookFindFilterActionViewItem = class NotebookFindFilterActionViewItem extends DropdownMenuActionViewItem {

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/find/notebookFindWidget.js

@@ -274,10 +274,10 @@ let NotebookFindWidget = class NotebookFindWidget extends SimpleFindReplaceWidge
     _getAriaLabel(label, currentMatch, searchString) {
         if (label === NLS_NO_RESULTS) {
             return searchString === ''
-                ? ( localize(10104, "{0} found", label))
-                : ( localize(10105, "{0} found for '{1}'", label, searchString));
+                ? ( localize(10135, "{0} found", label))
+                : ( localize(10136, "{0} found for '{1}'", label, searchString));
         }
-        return ( localize(10106, "{0} found for '{1}'", label, searchString));
+        return ( localize(10137, "{0} found for '{1}'", label, searchString));
     }
     dispose() {
         this._notebookEditor?.removeClassName(FIND_SHOW_TRANSITION);

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/cellOperations.js

@@ -164,9 +164,16 @@ async function moveCellRange(context, direction) {
     if (editor.isReadOnly) {
         return;
     }
-    const selections = editor.getSelections();
-    const modelRanges = expandCellRangesWithHiddenCells(editor, selections);
-    const range = modelRanges[0];
+    let range = undefined;
+    if (context.cell) {
+        const idx = editor.getCellIndex(context.cell);
+        range = { start: idx, end: idx + 1 };
+    }
+    else {
+        const selections = editor.getSelections();
+        const modelRanges = expandCellRangesWithHiddenCells(editor, selections);
+        range = modelRanges[0];
+    }
     if (!range || range.start === range.end) {
         return;
     }
@@ -295,7 +302,7 @@ async function joinSelectedCells(bulkEditService, notificationService, context)
     const cellKind = cells[0].cellKind;
     const isSameKind = cells.every(cell => cell.cellKind === cellKind);
     if (!isSameKind) {
-        const message = ( localize(10600, "Cannot join cells of different kinds"));
+        const message = ( localize(10628, "Cannot join cells of different kinds"));
         return notificationService.warn(message);
     }
     const firstCell = cells[0];
@@ -323,7 +330,7 @@ async function joinSelectedCells(bulkEditService, notificationService, context)
         }))));
     }
     if (edits.length) {
-        await bulkEditService.apply(edits, { quotableLabel: ( localize(10601, "Join Notebook Cells")) });
+        await bulkEditService.apply(edits, { quotableLabel: ( localize(10629, "Join Notebook Cells")) });
     }
 }
 async function joinNotebookCells(editor, range, direction, constraint) {

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/cellOutputActions.js

@@ -16,7 +16,7 @@ registerAction2(class ShowAllOutputsAction extends Action2 {
     constructor() {
         super({
             id: 'notebook.cellOuput.showEmptyOutputs',
-            title: ( localize(7921, "Show empty outputs")),
+            title: ( localize(8165, "Show empty outputs")),
             menu: {
                 id: MenuId.NotebookOutputToolbar,
                 when: ( (ContextKeyExpr.and(NOTEBOOK_CELL_HAS_OUTPUTS, NOTEBOOK_CELL_HAS_HIDDEN_OUTPUTS)))
@@ -41,7 +41,7 @@ registerAction2(class CopyCellOutputAction extends Action2 {
     constructor() {
         super({
             id: COPY_OUTPUT_COMMAND_ID,
-            title: ( localize(7922, "Copy Cell Output")),
+            title: ( localize(8166, "Copy Cell Output")),
             menu: {
                 id: MenuId.NotebookOutputToolbar,
                 when: NOTEBOOK_CELL_HAS_OUTPUTS
@@ -116,7 +116,7 @@ registerAction2(class OpenCellOutputInEditorAction extends Action2 {
     constructor() {
         super({
             id: OPEN_OUTPUT_COMMAND_ID,
-            title: ( localize(7923, "Open Cell Output in Text Editor")),
+            title: ( localize(8167, "Open Cell Output in Text Editor")),
             f1: false,
             category: NOTEBOOK_ACTIONS_CATEGORY,
             icon: copyIcon,