@codingame/monaco-vscode-api 1.81.8-next.3 → 1.82.0-next.0

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/mergeEditorInputModel.js

@@ -21,6 +21,7 @@ import { StorageCloseWithConflicts } from '../common/mergeEditor.js';
 import { IEditorService } from '../../../services/editor/common/editorService.js';
 import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
 import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
+var WorkspaceMergeEditorModeFactory_1;
 let TempFileMergeEditorModeFactory = class TempFileMergeEditorModeFactory {
     constructor(_mergeEditorTelemetry, _instantiationService, _textModelService, _modelService) {
         this._mergeEditorTelemetry = _mergeEditorTelemetry;
@@ -71,7 +72,7 @@ let TempFileMergeEditorInputModel = class TempFileMergeEditorInputModel extends
         this.savedAltVersionId = observableValue('initialAltVersionId', this.model.resultTextModel.getAlternativeVersionId());
         this.altVersionId = observableFromEvent(e => this.model.resultTextModel.onDidChangeContent(e), () =>
          this.model.resultTextModel.getAlternativeVersionId());
-        this.isDirty = derived('isDirty', (reader) => this.altVersionId.read(reader) !== this.savedAltVersionId.read(reader));
+        this.isDirty = derived((reader) =>  this.altVersionId.read(reader) !== this.savedAltVersionId.read(reader));
         this.finished = false;
     }
     dispose() {
@@ -192,6 +193,7 @@ TempFileMergeEditorInputModel = ( __decorate([
     ( __param(6, IEditorService))
 ], TempFileMergeEditorInputModel));
 let WorkspaceMergeEditorModeFactory = class WorkspaceMergeEditorModeFactory {
+    static { WorkspaceMergeEditorModeFactory_1 = this; }
     constructor(_mergeEditorTelemetry, _instantiationService, _textModelService, textFileService) {
         this._mergeEditorTelemetry = _mergeEditorTelemetry;
         this._instantiationService = _instantiationService;
@@ -222,7 +224,7 @@ let WorkspaceMergeEditorModeFactory = class WorkspaceMergeEditorModeFactory {
         if (!resultTextFileModel) {
             throw new BugIndicatingError();
         }
-        await resultTextFileModel.save({ source: WorkspaceMergeEditorModeFactory.FILE_SAVED_SOURCE });
+        await resultTextFileModel.save({ source: WorkspaceMergeEditorModeFactory_1.FILE_SAVED_SOURCE });
         const lines = resultTextFileModel.textEditorModel.getLinesContent();
         const hasConflictMarkers = ( lines.some(l => l.startsWith(conflictMarkers.start)));
         const resetResult = hasConflictMarkers;
@@ -235,7 +237,7 @@ let WorkspaceMergeEditorModeFactory = class WorkspaceMergeEditorModeFactory {
         return this._instantiationService.createInstance(WorkspaceMergeEditorInputModel, model, store, resultTextFileModel, this._mergeEditorTelemetry);
     }
 };
-WorkspaceMergeEditorModeFactory = ( __decorate([
+WorkspaceMergeEditorModeFactory = WorkspaceMergeEditorModeFactory_1 = ( __decorate([
     ( __param(1, IInstantiationService)),
     ( __param(2, ITextModelService)),
     ( __param(3, ITextFileService))

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/diffComputer.js

@@ -33,6 +33,33 @@ let MergeDiffComputer = class MergeDiffComputer {
             c.innerChanges?.map(ic => toRangeMapping(ic))
         ))));
         assertFn(() => {
+            for (const c of changes) {
+                const inputRange = c.inputRange;
+                const outputRange = c.outputRange;
+                const inputTextModel = c.inputTextModel;
+                const outputTextModel = c.outputTextModel;
+                for (const map of c.rangeMappings) {
+                    let inputRangesValid = inputRange.startLineNumber - 1 <= map.inputRange.startLineNumber
+                        && map.inputRange.endLineNumber <= inputRange.endLineNumberExclusive;
+                    if (inputRangesValid && map.inputRange.startLineNumber === inputRange.startLineNumber - 1) {
+                        inputRangesValid = map.inputRange.endColumn >= inputTextModel.getLineMaxColumn(map.inputRange.startLineNumber);
+                    }
+                    if (inputRangesValid && map.inputRange.endLineNumber === inputRange.endLineNumberExclusive) {
+                        inputRangesValid = map.inputRange.endColumn === 1;
+                    }
+                    let outputRangesValid = outputRange.startLineNumber - 1 <= map.outputRange.startLineNumber
+                        && map.outputRange.endLineNumber <= outputRange.endLineNumberExclusive;
+                    if (outputRangesValid && map.outputRange.startLineNumber === outputRange.startLineNumber - 1) {
+                        outputRangesValid = map.outputRange.endColumn >= outputTextModel.getLineMaxColumn(map.outputRange.endLineNumber);
+                    }
+                    if (outputRangesValid && map.outputRange.endLineNumber === outputRange.endLineNumberExclusive) {
+                        outputRangesValid = map.outputRange.endColumn === 1;
+                    }
+                    if (!inputRangesValid || !outputRangesValid) {
+                        return false;
+                    }
+                }
+            }
             return changes.length === 0 || (changes[0].inputRange.startLineNumber === changes[0].outputRange.startLineNumber &&
                 checkAdjacentItems(changes, (m1, m2) => m2.inputRange.startLineNumber - m1.inputRange.endLineNumberExclusive === m2.outputRange.startLineNumber - m1.outputRange.endLineNumberExclusive &&
                     m1.inputRange.endLineNumberExclusive < m2.inputRange.startLineNumber &&

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/mapping.js

@@ -168,30 +168,6 @@ class DetailedLineRangeMapping extends LineRangeMapping {
         this.inputTextModel = inputTextModel;
         this.outputTextModel = outputTextModel;
         this.rangeMappings = rangeMappings || [( (new RangeMapping(this.inputRange.toRange(), this.outputRange.toRange())))];
-        assertFn(() => {
-            for (const map of this.rangeMappings) {
-                let inputRangesValid = inputRange.startLineNumber - 1 <= map.inputRange.startLineNumber
-                    && map.inputRange.endLineNumber <= inputRange.endLineNumberExclusive;
-                if (inputRangesValid && map.inputRange.startLineNumber === inputRange.startLineNumber - 1) {
-                    inputRangesValid = map.inputRange.endColumn >= inputTextModel.getLineMaxColumn(map.inputRange.startLineNumber);
-                }
-                if (inputRangesValid && map.inputRange.endLineNumber === inputRange.endLineNumberExclusive) {
-                    inputRangesValid = map.inputRange.endColumn === 1;
-                }
-                let outputRangesValid = outputRange.startLineNumber - 1 <= map.outputRange.startLineNumber
-                    && map.outputRange.endLineNumber <= outputRange.endLineNumberExclusive;
-                if (outputRangesValid && map.outputRange.startLineNumber === outputRange.startLineNumber - 1) {
-                    outputRangesValid = map.outputRange.endColumn >= outputTextModel.getLineMaxColumn(map.outputRange.startLineNumber);
-                }
-                if (outputRangesValid && map.outputRange.endLineNumber === outputRange.endLineNumberExclusive) {
-                    outputRangesValid = map.outputRange.endColumn === 1;
-                }
-                if (!inputRangesValid || !outputRangesValid) {
-                    return false;
-                }
-            }
-            return true;
-        });
     }
     addOutputLineDelta(delta) {
         return (

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/mergeEditorModel.js

@@ -27,12 +27,12 @@ let MergeEditorModel = class MergeEditorModel extends EditorModel {
         this.input1TextModelDiffs = this._register(( new TextModelDiffs(this.base, this.input1.textModel, this.diffComputer)));
         this.input2TextModelDiffs = this._register(( new TextModelDiffs(this.base, this.input2.textModel, this.diffComputer)));
         this.resultTextModelDiffs = this._register(( new TextModelDiffs(this.base, this.resultTextModel, this.diffComputer)));
-        this.modifiedBaseRanges = derived('modifiedBaseRanges', (reader) => {
+        this.modifiedBaseRanges = derived((reader) => {
             const input1Diffs = this.input1TextModelDiffs.diffs.read(reader);
             const input2Diffs = this.input2TextModelDiffs.diffs.read(reader);
             return ModifiedBaseRange.fromDiffs(input1Diffs, input2Diffs, this.base, this.input1.textModel, this.input2.textModel);
         });
-        this.modifiedBaseRangeResultStates = derived('modifiedBaseRangeResultStates', reader => {
+        this.modifiedBaseRangeResultStates = derived(reader => {
             const map = ( new Map(( this.modifiedBaseRanges.read(reader).map((s) => [
                 s, ( new ModifiedBaseRangeData(s))
             ]))));
@@ -42,23 +42,23 @@ let MergeEditorModel = class MergeEditorModel extends EditorModel {
         this.baseInput1Diffs = this.input1TextModelDiffs.diffs;
         this.baseInput2Diffs = this.input2TextModelDiffs.diffs;
         this.baseResultDiffs = this.resultTextModelDiffs.diffs;
-        this.input1ResultMapping = derived('input1ResultMapping', reader => {
+        this.input1ResultMapping = derived(reader => {
             return this.getInputResultMapping(this.baseInput1Diffs.read(reader), this.baseResultDiffs.read(reader), this.input1.textModel.getLineCount());
         });
-        this.resultInput1Mapping = derived('resultInput1Mapping', reader => this.input1ResultMapping.read(reader).reverse());
-        this.input2ResultMapping = derived('input2ResultMapping', reader => {
+        this.resultInput1Mapping = derived(reader =>  this.input1ResultMapping.read(reader).reverse());
+        this.input2ResultMapping = derived(reader => {
             return this.getInputResultMapping(this.baseInput2Diffs.read(reader), this.baseResultDiffs.read(reader), this.input2.textModel.getLineCount());
         });
-        this.resultInput2Mapping = derived('resultInput2Mapping', reader => this.input2ResultMapping.read(reader).reverse());
-        this.baseResultMapping = derived('baseResultMapping', reader => {
+        this.resultInput2Mapping = derived(reader =>  this.input2ResultMapping.read(reader).reverse());
+        this.baseResultMapping = derived(reader => {
             const map = ( new DocumentLineRangeMap(this.baseResultDiffs.read(reader), -1));
             return ( new DocumentLineRangeMap(( map.lineRangeMappings.map((m) => m.inputRange.isEmpty || m.outputRange.isEmpty
                 ? ( new LineRangeMapping(
             m.inputRange.deltaStart(-1), m.outputRange.deltaStart(-1)))
                 : m)), map.inputLineCount));
         });
-        this.resultBaseMapping = derived('resultBaseMapping', reader => this.baseResultMapping.read(reader).reverse());
-        this.diffComputingState = derived('diffComputingState', reader => {
+        this.resultBaseMapping = derived(reader =>  this.baseResultMapping.read(reader).reverse());
+        this.diffComputingState = derived(reader => {
             const states = ( [
                 this.input1TextModelDiffs,
                 this.input2TextModelDiffs,
@@ -72,7 +72,7 @@ let MergeEditorModel = class MergeEditorModel extends EditorModel {
             }
             return 2 ;
         });
-        this.inputDiffComputingState = derived('inputDiffComputingState', reader => {
+        this.inputDiffComputingState = derived(reader => {
             const states = ( [
                 this.input1TextModelDiffs,
                 this.input2TextModelDiffs,
@@ -85,10 +85,10 @@ let MergeEditorModel = class MergeEditorModel extends EditorModel {
             }
             return 2 ;
         });
-        this.isUpToDate = derived('isUpToDate', reader => this.diffComputingState.read(reader) === 2 );
+        this.isUpToDate = derived(reader =>  this.diffComputingState.read(reader) === 2 );
         this.onInitialized = waitForState(this.diffComputingState, state => state === 2 ).then(() => { });
         this.firstRun = true;
-        this.unhandledConflictsCount = derived('unhandledConflictsCount', reader => {
+        this.unhandledConflictsCount = derived(reader =>  {
             const map = this.modifiedBaseRangeResultStates.read(reader);
             let unhandledCount = 0;
             for (const [_key, value] of map) {
@@ -108,7 +108,7 @@ let MergeEditorModel = class MergeEditorModel extends EditorModel {
         });
         initializePromise.then(() => {
             let shouldRecomputeHandledFromAccepted = true;
-            this._register(autorunHandleChanges('Merge Editor Model: Recompute State From Result', {
+            this._register(autorunHandleChanges({
                 handleChange: (ctx) => {
                     if (ctx.didChange(this.modifiedBaseRangeResultStates)) {
                         shouldRecomputeHandledFromAccepted = true;
@@ -560,7 +560,7 @@ class ModifiedBaseRangeData {
         this.handledInput2 = observableValue(`BaseRangeHandledState${this.baseRange.baseRange}.Input2`, false);
         this.computedFromDiffing = false;
         this.previousNonDiffingState = undefined;
-        this.handled = derived('handled', reader => this.handledInput1.read(reader) && this.handledInput2.read(reader));
+        this.handled = derived(reader =>  this.handledInput1.read(reader) && this.handledInput2.read(reader));
     }
 }
 class MarkAsHandledUndoRedoElement {

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/model/textModelDiffs.js

@@ -22,7 +22,7 @@ class TextModelDiffs extends Disposable {
         this.isDisposed = false;
         this.isInitializing = true;
         const recomputeSignal = observableSignal('recompute');
-        this._register(autorun('Update diff state', reader => {
+        this._register(autorun(reader => {
             recomputeSignal.read(reader);
             this.recompute(reader);
         }));

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

@@ -11,11 +11,6 @@ KERNEL_RECOMMENDATIONS.get(IPYNB_VIEW_TYPE)?.set('python', {
     ],
     displayName: 'Python + Jupyter',
 });
-var CellEditState;
-( (function(CellEditState) {
-    CellEditState[CellEditState["Preview"] = 0] = "Preview";
-    CellEditState[CellEditState["Editing"] = 1] = "Editing";
-})(CellEditState || (CellEditState = {})));
 function getNotebookEditorFromEditorPane(editorPane) {
     if (!editorPane) {
         return;
@@ -29,4 +24,4 @@ function getNotebookEditorFromEditorPane(editorPane) {
     }
     return undefined;
 }
-export { CellEditState, IPYNB_VIEW_TYPE, JUPYTER_EXTENSION_ID, KERNEL_RECOMMENDATIONS, getNotebookEditorFromEditorPane };
+export { IPYNB_VIEW_TYPE, JUPYTER_EXTENSION_ID, KERNEL_RECOMMENDATIONS, getNotebookEditorFromEditorPane };

package/vscode/src/vs/workbench/contrib/output/browser/logViewer.js

@@ -17,16 +17,18 @@ import { ITextFileService } from '../../../services/textfile/common/textfiles.js
 import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
 import { IFilesConfigurationService } from '../../../services/filesConfiguration/common/filesConfigurationService.js';
+var LogViewerInput_1, LogViewer_1;
 let LogViewerInput = class LogViewerInput extends TextResourceEditorInput {
+    static { LogViewerInput_1 = this; }
     static { this.ID = 'workbench.editorinputs.output'; }
     get typeId() {
-        return LogViewerInput.ID;
+        return LogViewerInput_1.ID;
     }
     constructor(outputChannelDescriptor, textModelResolverService, textFileService, editorService, fileService, labelService, filesConfigurationService) {
         super(( URI.from({ scheme: LOG_SCHEME, path: outputChannelDescriptor.id })), basename(outputChannelDescriptor.file.path), dirname(outputChannelDescriptor.file.path), undefined, undefined, textModelResolverService, textFileService, editorService, fileService, labelService, filesConfigurationService);
     }
 };
-LogViewerInput = ( __decorate([
+LogViewerInput = LogViewerInput_1 = ( __decorate([
     ( __param(1, ITextModelService)),
     ( __param(2, ITextFileService)),
     ( __param(3, IEditorService)),
@@ -35,9 +37,10 @@ LogViewerInput = ( __decorate([
     ( __param(6, IFilesConfigurationService))
 ], LogViewerInput));
 let LogViewer = class LogViewer extends AbstractTextResourceEditor {
+    static { LogViewer_1 = this; }
     static { this.LOG_VIEWER_EDITOR_ID = 'workbench.editors.logViewer'; }
     constructor(telemetryService, instantiationService, storageService, textResourceConfigurationService, themeService, editorGroupService, editorService, fileService) {
-        super(LogViewer.LOG_VIEWER_EDITOR_ID, telemetryService, instantiationService, storageService, textResourceConfigurationService, themeService, editorGroupService, editorService, fileService);
+        super(LogViewer_1.LOG_VIEWER_EDITOR_ID, telemetryService, instantiationService, storageService, textResourceConfigurationService, themeService, editorGroupService, editorService, fileService);
     }
     getConfigurationOverrides() {
         const options = super.getConfigurationOverrides();
@@ -51,7 +54,7 @@ let LogViewer = class LogViewer extends AbstractTextResourceEditor {
         return ( localize('logViewerAriaLabel', "Log viewer"));
     }
 };
-LogViewer = ( __decorate([
+LogViewer = LogViewer_1 = ( __decorate([
     ( __param(0, ITelemetryService)),
     ( __param(1, IInstantiationService)),
     ( __param(2, IStorageService)),

package/vscode/src/vs/workbench/contrib/output/browser/outputLinkProvider.js

@@ -7,14 +7,16 @@ import { createWebWorker } from 'monaco-editor/esm/vs/editor/browser/services/we
 import { dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { ILanguageConfigurationService } from 'monaco-editor/esm/vs/editor/common/languages/languageConfigurationRegistry.js';
 import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+var OutputLinkProvider_1;
 let OutputLinkProvider = class OutputLinkProvider {
+    static { OutputLinkProvider_1 = this; }
     static { this.DISPOSE_WORKER_TIME = 3 * 60 * 1000; }
     constructor(contextService, modelService, languageConfigurationService, languageFeaturesService) {
         this.contextService = contextService;
         this.modelService = modelService;
         this.languageConfigurationService = languageConfigurationService;
         this.languageFeaturesService = languageFeaturesService;
-        this.disposeWorkerScheduler = ( new RunOnceScheduler(() => this.disposeWorker(), OutputLinkProvider.DISPOSE_WORKER_TIME));
+        this.disposeWorkerScheduler = ( new RunOnceScheduler(() => this.disposeWorker(), OutputLinkProvider_1.DISPOSE_WORKER_TIME));
         this.registerListeners();
         this.updateLinkProviderWorker();
     }
@@ -65,7 +67,7 @@ let OutputLinkProvider = class OutputLinkProvider {
         }
     }
 };
-OutputLinkProvider = ( __decorate([
+OutputLinkProvider = OutputLinkProvider_1 = ( __decorate([
     ( __param(0, IWorkspaceContextService)),
     ( __param(1, IModelService)),
     ( __param(2, ILanguageConfigurationService)),

package/vscode/src/vs/workbench/contrib/preferences/browser/keybindingWidgets.js

@@ -15,10 +15,10 @@ import { IContextViewService } from 'monaco-editor/esm/vs/platform/contextview/b
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { asCssVariable, editorWidgetBackground, editorWidgetForeground, widgetShadow } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
 import { SearchWidget } from './preferencesWidgets.js';
-import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
 import { Promises, timeout } from 'monaco-editor/esm/vs/base/common/async.js';
 import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { defaultInputBoxStyles, defaultKeybindingLabelStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+var DefineKeybindingWidget_1, DefineKeybindingOverlayWidget_1;
 let KeybindingsSearchWidget = class KeybindingsSearchWidget extends SearchWidget {
     constructor(parent, options, contextViewService, instantiationService, contextKeyService, keybindingService) {
         super(parent, options, contextViewService, instantiationService, contextKeyService, keybindingService);
@@ -98,6 +98,7 @@ KeybindingsSearchWidget = ( __decorate([
     ( __param(5, IKeybindingService))
 ], KeybindingsSearchWidget));
 let DefineKeybindingWidget = class DefineKeybindingWidget extends Widget {
+    static { DefineKeybindingWidget_1 = this; }
     static { this.WIDTH = 400; }
     static { this.HEIGHT = 110; }
     constructor(parent, instantiationService) {
@@ -113,8 +114,8 @@ let DefineKeybindingWidget = class DefineKeybindingWidget extends Widget {
         this._domNode = createFastDomNode(document.createElement('div'));
         this._domNode.setDisplay('none');
         this._domNode.setClassName('defineKeybindingWidget');
-        this._domNode.setWidth(DefineKeybindingWidget.WIDTH);
-        this._domNode.setHeight(DefineKeybindingWidget.HEIGHT);
+        this._domNode.setWidth(DefineKeybindingWidget_1.WIDTH);
+        this._domNode.setHeight(DefineKeybindingWidget_1.HEIGHT);
         const message = ( nls.localize(
             'defineKeybinding.initial',
             "Press desired key combination and then press ENTER."
@@ -158,9 +159,9 @@ let DefineKeybindingWidget = class DefineKeybindingWidget extends Widget {
         });
     }
     layout(layout) {
-        const top = Math.round((layout.height - DefineKeybindingWidget.HEIGHT) / 2);
+        const top = Math.round((layout.height - DefineKeybindingWidget_1.HEIGHT) / 2);
         this._domNode.setTop(top);
-        const left = Math.round((layout.width - DefineKeybindingWidget.WIDTH) / 2);
+        const left = Math.round((layout.width - DefineKeybindingWidget_1.WIDTH) / 2);
         this._domNode.setLeft(left);
     }
     printExisting(numberOfExisting) {
@@ -188,7 +189,7 @@ let DefineKeybindingWidget = class DefineKeybindingWidget extends Widget {
         dom.clearNode(this._outputNode);
         dom.clearNode(this._showExistingKeybindingsNode);
         const firstLabel = ( new KeybindingLabel(this._outputNode, OS, defaultKeybindingLabelStyles));
-        firstLabel.set(withNullAsUndefined(this._chords?.[0]));
+        firstLabel.set(this._chords?.[0] ?? undefined);
         if (this._chords) {
             for (let i = 1; i < this._chords.length; i++) {
                 this._outputNode.appendChild(document.createTextNode(( nls.localize('defineKeybinding.chordsTo', "chord to"))));
@@ -229,10 +230,11 @@ let DefineKeybindingWidget = class DefineKeybindingWidget extends Widget {
         this._onHide.fire();
     }
 };
-DefineKeybindingWidget = ( __decorate([
+DefineKeybindingWidget = DefineKeybindingWidget_1 = ( __decorate([
     ( __param(1, IInstantiationService))
 ], DefineKeybindingWidget));
-(class DefineKeybindingOverlayWidget extends Disposable {
+let DefineKeybindingOverlayWidget = class DefineKeybindingOverlayWidget extends Disposable {
+    static { DefineKeybindingOverlayWidget_1 = this; }
     static { this.ID = 'editor.contrib.defineKeybindingWidget'; }
     constructor(_editor, instantiationService) {
         super();
@@ -241,7 +243,7 @@ DefineKeybindingWidget = ( __decorate([
         this._editor.addOverlayWidget(this);
     }
     getId() {
-        return DefineKeybindingOverlayWidget.ID;
+        return DefineKeybindingOverlayWidget_1.ID;
     }
     getDomNode() {
         return this._widget.domNode;
@@ -263,5 +265,8 @@ DefineKeybindingWidget = ( __decorate([
         this._widget.layout(new dom.Dimension(layoutInfo.width, layoutInfo.height));
         return this._widget.define();
     }
-});
-export { DefineKeybindingWidget, KeybindingsSearchWidget };
+};
+DefineKeybindingOverlayWidget = DefineKeybindingOverlayWidget_1 = ( __decorate([
+    ( __param(1, IInstantiationService))
+], DefineKeybindingOverlayWidget));
+export { DefineKeybindingOverlayWidget, DefineKeybindingWidget, KeybindingsSearchWidget };

package/vscode/src/vs/workbench/contrib/preferences/browser/keybindingsEditor.js

@@ -42,11 +42,13 @@ import { SuggestEnabledInput } from '../../codeEditor/browser/suggestEnabledInpu
 import { settingsTextInputBorder } from '../common/settingsEditorColorRegistry.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { registerNavigableContainer } from '../../../browser/actions/widgetNavigationCommands.js';
+var KeybindingsEditor_1, ActionsColumnRenderer_1, SourceColumnRenderer_1, WhenColumnRenderer_1;
 const $ = dom.$;
 let KeybindingsEditor = class KeybindingsEditor extends EditorPane {
+    static { KeybindingsEditor_1 = this; }
     static { this.ID = 'workbench.editor.keybindings'; }
     constructor(telemetryService, themeService, keybindingsService, contextMenuService, keybindingEditingService, contextKeyService, notificationService, clipboardService, instantiationService, editorService, storageService, configurationService) {
-        super(KeybindingsEditor.ID, telemetryService, themeService, storageService);
+        super(KeybindingsEditor_1.ID, telemetryService, themeService, storageService);
         this.keybindingsService = keybindingsService;
         this.contextMenuService = contextMenuService;
         this.keybindingEditingService = keybindingEditingService;
@@ -708,7 +710,7 @@ let KeybindingsEditor = class KeybindingsEditor extends EditorPane {
         )));
     }
 };
-KeybindingsEditor = ( __decorate([
+KeybindingsEditor = KeybindingsEditor_1 = ( __decorate([
     ( __param(0, ITelemetryService)),
     ( __param(1, IThemeService)),
     ( __param(2, IKeybindingService)),
@@ -742,11 +744,12 @@ class Delegate {
     }
 }
 let ActionsColumnRenderer = class ActionsColumnRenderer {
+    static { ActionsColumnRenderer_1 = this; }
     static { this.TEMPLATE_ID = 'actions'; }
     constructor(keybindingsEditor, keybindingsService) {
         this.keybindingsEditor = keybindingsEditor;
         this.keybindingsService = keybindingsService;
-        this.templateId = ActionsColumnRenderer.TEMPLATE_ID;
+        this.templateId = ActionsColumnRenderer_1.TEMPLATE_ID;
     }
     renderTemplate(container) {
         const element = dom.append(container, $('.actions'));
@@ -796,7 +799,7 @@ let ActionsColumnRenderer = class ActionsColumnRenderer {
         templateData.actionBar.dispose();
     }
 };
-ActionsColumnRenderer = ( __decorate([
+ActionsColumnRenderer = ActionsColumnRenderer_1 = ( __decorate([
     ( __param(1, IKeybindingService))
 ], ActionsColumnRenderer));
 class CommandColumnRenderer {
@@ -886,10 +889,11 @@ function onClick(element, callback) {
     return disposables;
 }
 let SourceColumnRenderer = class SourceColumnRenderer {
+    static { SourceColumnRenderer_1 = this; }
     static { this.TEMPLATE_ID = 'source'; }
     constructor(extensionsWorkbenchService) {
         this.extensionsWorkbenchService = extensionsWorkbenchService;
-        this.templateId = SourceColumnRenderer.TEMPLATE_ID;
+        this.templateId = SourceColumnRenderer_1.TEMPLATE_ID;
     }
     renderTemplate(container) {
         const sourceColumn = dom.append(container, $('.source'));
@@ -930,7 +934,7 @@ let SourceColumnRenderer = class SourceColumnRenderer {
         templateData.disposables.dispose();
     }
 };
-SourceColumnRenderer = ( __decorate([
+SourceColumnRenderer = SourceColumnRenderer_1 = ( __decorate([
     ( __param(0, IExtensionsWorkbenchService))
 ], SourceColumnRenderer));
 let WhenInputWidget = class WhenInputWidget extends Disposable {
@@ -971,11 +975,12 @@ WhenInputWidget = ( __decorate([
     ( __param(3, IContextKeyService))
 ], WhenInputWidget));
 let WhenColumnRenderer = class WhenColumnRenderer {
+    static { WhenColumnRenderer_1 = this; }
     static { this.TEMPLATE_ID = 'when'; }
     constructor(keybindingsEditor, instantiationService) {
         this.keybindingsEditor = keybindingsEditor;
         this.instantiationService = instantiationService;
-        this.templateId = WhenColumnRenderer.TEMPLATE_ID;
+        this.templateId = WhenColumnRenderer_1.TEMPLATE_ID;
     }
     renderTemplate(container) {
         const element = dom.append(container, $('.when'));
@@ -1034,7 +1039,7 @@ let WhenColumnRenderer = class WhenColumnRenderer {
         templateData.disposables.dispose();
     }
 };
-WhenColumnRenderer = ( __decorate([
+WhenColumnRenderer = WhenColumnRenderer_1 = ( __decorate([
     ( __param(1, IInstantiationService))
 ], WhenColumnRenderer));
 class AccessibilityProvider {

package/vscode/src/vs/workbench/contrib/preferences/browser/preferences.contribution.js

@@ -1,6 +1,6 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { KeyChord } from 'monaco-editor/esm/vs/base/common/keyCodes.js';
-import { Disposable, MutableDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Disposable, DisposableStore, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
 import { isObject, isString, isBoolean } from 'monaco-editor/esm/vs/base/common/types.js';
 import './media/preferences.css.js';
@@ -21,7 +21,7 @@ import { PICK_WORKSPACE_FOLDER_COMMAND_ID } from '../../../browser/actions/works
 import { EditorPaneDescriptor } from '../../../browser/editor.js';
 import { Extensions } from '../../../common/contributions.js';
 import { EditorExtensions } from '../../../common/editor.js';
-import { ResourceContextKey, WorkbenchStateContext } from '../../../common/contextkeys.js';
+import { WorkbenchStateContext, ResourceContextKey } from '../../../common/contextkeys.js';
 import { ExplorerRootContext, ExplorerFolderContext } from '../../files/common/files.js';
 import { KeybindingsEditor } from './keybindingsEditor.js';
 import { ConfigureLanguageBasedSettingsAction } from './preferencesActions.js';
@@ -190,66 +190,6 @@ let PreferencesActionsContribution = class PreferencesActionsContribution extend
                 return accessor.get(IPreferencesService).openRawDefaultSettings();
             }
         });
-        const registerOpenUserSettingsEditorFromJsonActionDisposables = this._register(( (new MutableDisposable())));
-        const openUserSettingsEditorWhen = ( (ContextKeyExpr.and(
-             (ContextKeyExpr.or( (ResourceContextKey.Resource.isEqualTo(
-                 (this.userDataProfileService.currentProfile.settingsResource.toString())
-            )),  (ResourceContextKey.Resource.isEqualTo(
-                 (this.userDataProfilesService.defaultProfile.settingsResource.toString())
-            )))),
-            ContextKeyExpr.not('isInDiffEditor')
-        )));
-        const registerOpenUserSettingsEditorFromJsonAction = () => {
-            registerOpenUserSettingsEditorFromJsonActionDisposables.value = registerAction2(class extends Action2 {
-                constructor() {
-                    super({
-                        id: '_workbench.openUserSettingsEditor',
-                        title: OPEN_USER_SETTINGS_UI_TITLE,
-                        icon: preferencesOpenSettingsIcon,
-                        menu: [{
-                                id: MenuId.EditorTitle,
-                                when: openUserSettingsEditorWhen,
-                                group: 'navigation',
-                                order: 1
-                            }]
-                    });
-                }
-                run(accessor, args) {
-                    args = sanitizeOpenSettingsArgs(args);
-                    return accessor.get(IPreferencesService).openUserSettings({ jsonEditor: false, ...args });
-                }
-            });
-        };
-        const openSettingsJsonWhen = ( (ContextKeyExpr.and(
-            CONTEXT_SETTINGS_EDITOR,
-             (CONTEXT_SETTINGS_JSON_EDITOR.toNegated())
-        )));
-        registerAction2(class extends Action2 {
-            constructor() {
-                super({
-                    id: SETTINGS_EDITOR_COMMAND_SWITCH_TO_JSON,
-                    title: { value: ( (nls.localize('openSettingsJson', "Open Settings (JSON)"))), original: 'Open Settings (JSON)' },
-                    icon: preferencesOpenSettingsIcon,
-                    menu: [{
-                            id: MenuId.EditorTitle,
-                            when: openSettingsJsonWhen,
-                            group: 'navigation',
-                            order: 1
-                        }]
-                });
-            }
-            run(accessor) {
-                const editorPane = accessor.get(IEditorService).activeEditorPane;
-                if (editorPane instanceof SettingsEditor2) {
-                    return editorPane.switchToSettingsFile();
-                }
-                return null;
-            }
-        });
-        registerOpenUserSettingsEditorFromJsonAction();
-        this._register(this.userDataProfileService.onDidChangeCurrentProfile(() => {
-            registerOpenUserSettingsEditorFromJsonAction();
-        }));
         registerAction2(class extends Action2 {
             constructor() {
                 super({
@@ -1088,7 +1028,82 @@ PreferencesActionsContribution = ( (__decorate([
     ( (__param(5, IExtensionService))),
     ( (__param(6, IUserDataProfilesService)))
 ], PreferencesActionsContribution)));
+let SettingsEditorTitleContribution = class SettingsEditorTitleContribution extends Disposable {
+    constructor(userDataProfileService, userDataProfilesService) {
+        super();
+        this.userDataProfileService = userDataProfileService;
+        this.userDataProfilesService = userDataProfilesService;
+        this.registerSettingsEditorTitleActions();
+    }
+    registerSettingsEditorTitleActions() {
+        const registerOpenUserSettingsEditorFromJsonActionDisposables = this._register(( (new MutableDisposable())));
+        const openUserSettingsEditorWhen = ( (ContextKeyExpr.and(
+             (ContextKeyExpr.or( (ResourceContextKey.Resource.isEqualTo(
+                 (this.userDataProfileService.currentProfile.settingsResource.toString())
+            )),  (ResourceContextKey.Resource.isEqualTo(
+                 (this.userDataProfilesService.defaultProfile.settingsResource.toString())
+            )))),
+            ContextKeyExpr.not('isInDiffEditor')
+        )));
+        const registerOpenUserSettingsEditorFromJsonAction = () => {
+            registerOpenUserSettingsEditorFromJsonActionDisposables.value = registerAction2(class extends Action2 {
+                constructor() {
+                    super({
+                        id: '_workbench.openUserSettingsEditor',
+                        title: OPEN_USER_SETTINGS_UI_TITLE,
+                        icon: preferencesOpenSettingsIcon,
+                        menu: [{
+                                id: MenuId.EditorTitle,
+                                when: openUserSettingsEditorWhen,
+                                group: 'navigation',
+                                order: 1
+                            }]
+                    });
+                }
+                run(accessor, args) {
+                    args = sanitizeOpenSettingsArgs(args);
+                    return accessor.get(IPreferencesService).openUserSettings({ jsonEditor: false, ...args });
+                }
+            });
+        };
+        registerOpenUserSettingsEditorFromJsonAction();
+        this._register(this.userDataProfileService.onDidChangeCurrentProfile(() => {
+            registerOpenUserSettingsEditorFromJsonAction();
+        }));
+        const openSettingsJsonWhen = ( (ContextKeyExpr.and(
+            CONTEXT_SETTINGS_EDITOR,
+             (CONTEXT_SETTINGS_JSON_EDITOR.toNegated())
+        )));
+        registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: SETTINGS_EDITOR_COMMAND_SWITCH_TO_JSON,
+                    title: { value: ( (nls.localize('openSettingsJson', "Open Settings (JSON)"))), original: 'Open Settings (JSON)' },
+                    icon: preferencesOpenSettingsIcon,
+                    menu: [{
+                            id: MenuId.EditorTitle,
+                            when: openSettingsJsonWhen,
+                            group: 'navigation',
+                            order: 1
+                        }]
+                });
+            }
+            run(accessor) {
+                const editorPane = accessor.get(IEditorService).activeEditorPane;
+                if (editorPane instanceof SettingsEditor2) {
+                    return editorPane.switchToSettingsFile();
+                }
+                return null;
+            }
+        });
+    }
+};
+SettingsEditorTitleContribution = ( (__decorate([
+    ( (__param(0, IUserDataProfileService))),
+    ( (__param(1, IUserDataProfilesService)))
+], SettingsEditorTitleContribution)));
 const workbenchContributionsRegistry = ( (Registry.as(Extensions.Workbench)));
 workbenchContributionsRegistry.registerWorkbenchContribution(PreferencesActionsContribution, 1 );
 workbenchContributionsRegistry.registerWorkbenchContribution(PreferencesContribution, 1 );
+workbenchContributionsRegistry.registerWorkbenchContribution(SettingsEditorTitleContribution, 3 );
 registerEditorContribution(SettingsEditorContribution.ID, SettingsEditorContribution, 1 );