@codingame/monaco-vscode-api 25.1.1 → 26.0.0

package/vscode/src/vs/workbench/browser/parts/editor/editorStatus.js

@@ -8,7 +8,7 @@ import { format, splitLines, compare } from '../../../../base/common/strings.js'
 import { isEqual, extname, basename } from '../../../../base/common/resources.js';
 import { areFunctions, assertReturnsDefined } from '../../../../base/common/types.js';
 import { URI } from '../../../../base/common/uri.js';
-import { Action } from '../../../../base/common/actions.js';
+import { toAction } from '../../../../base/common/actions.js';
 import { Language } from '../../../../base/common/platform.js';
 import { UntitledTextEditorInput } from '../../../services/untitled/common/untitledTextEditorInput.js';
 import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
@@ -60,7 +60,6 @@ import { IEditorGroupsService } from '../../../services/editor/common/editorGrou
 import { InputMode } from '../../../../editor/common/inputMode.js';
 import { IDialogService } from '../../../../platform/dialogs/common/dialogs.service.js';
 
-var ShowLanguageExtensionsAction_1;
 registerCss(editorstatus);
 class SideBySideEditorEncodingSupport {
     constructor(primary, secondary) {
@@ -114,7 +113,7 @@ function toEditorWithLanguageSupport(input) {
         return primaryLanguageSupport;
     }
     const languageSupport = input;
-    if (typeof languageSupport.setLanguageId === 'function') {
+    if (typeof languageSupport.setLanguageId === "function") {
         return languageSupport;
     }
     return null;
@@ -145,85 +144,94 @@ class StateChange {
         this.metadata = this.metadata || other.metadata;
     }
     hasChanges() {
-        return this.indentation
-            || this.selectionStatus
-            || this.languageId
-            || this.languageStatus
-            || this.encoding
-            || this.EOL
-            || this.tabFocusMode
-            || this.inputMode
-            || this.columnSelectionMode
-            || this.metadata;
+        return this.indentation || this.selectionStatus || this.languageId || this.languageStatus || this.encoding || this.EOL || this.tabFocusMode || this.inputMode || this.columnSelectionMode || this.metadata;
     }
 }
 class State {
-    get selectionStatus() { return this._selectionStatus; }
-    get languageId() { return this._languageId; }
-    get encoding() { return this._encoding; }
-    get EOL() { return this._EOL; }
-    get indentation() { return this._indentation; }
-    get tabFocusMode() { return this._tabFocusMode; }
-    get inputMode() { return this._inputMode; }
-    get columnSelectionMode() { return this._columnSelectionMode; }
-    get metadata() { return this._metadata; }
+    get selectionStatus() {
+        return this._selectionStatus;
+    }
+    get languageId() {
+        return this._languageId;
+    }
+    get encoding() {
+        return this._encoding;
+    }
+    get EOL() {
+        return this._EOL;
+    }
+    get indentation() {
+        return this._indentation;
+    }
+    get tabFocusMode() {
+        return this._tabFocusMode;
+    }
+    get inputMode() {
+        return this._inputMode;
+    }
+    get columnSelectionMode() {
+        return this._columnSelectionMode;
+    }
+    get metadata() {
+        return this._metadata;
+    }
     update(update) {
         const change = ( new StateChange());
         switch (update.type) {
-            case 'selectionStatus':
-                if (this._selectionStatus !== update.selectionStatus) {
-                    this._selectionStatus = update.selectionStatus;
-                    change.selectionStatus = true;
-                }
-                break;
-            case 'indentation':
-                if (this._indentation !== update.indentation) {
-                    this._indentation = update.indentation;
-                    change.indentation = true;
-                }
-                break;
-            case 'languageId':
-                if (this._languageId !== update.languageId) {
-                    this._languageId = update.languageId;
-                    change.languageId = true;
-                }
-                break;
-            case 'encoding':
-                if (this._encoding !== update.encoding) {
-                    this._encoding = update.encoding;
-                    change.encoding = true;
-                }
-                break;
-            case 'EOL':
-                if (this._EOL !== update.EOL) {
-                    this._EOL = update.EOL;
-                    change.EOL = true;
-                }
-                break;
-            case 'tabFocusMode':
-                if (this._tabFocusMode !== update.tabFocusMode) {
-                    this._tabFocusMode = update.tabFocusMode;
-                    change.tabFocusMode = true;
-                }
-                break;
-            case 'inputMode':
-                if (this._inputMode !== update.inputMode) {
-                    this._inputMode = update.inputMode;
-                    change.inputMode = true;
-                }
-                break;
-            case 'columnSelectionMode':
-                if (this._columnSelectionMode !== update.columnSelectionMode) {
-                    this._columnSelectionMode = update.columnSelectionMode;
-                    change.columnSelectionMode = true;
-                }
-                break;
-            case 'metadata':
-                if (this._metadata !== update.metadata) {
-                    this._metadata = update.metadata;
-                    change.metadata = true;
-                }
-                break;
+        case "selectionStatus":
+            if (this._selectionStatus !== update.selectionStatus) {
+                this._selectionStatus = update.selectionStatus;
+                change.selectionStatus = true;
+            }
+            break;
+        case "indentation":
+            if (this._indentation !== update.indentation) {
+                this._indentation = update.indentation;
+                change.indentation = true;
+            }
+            break;
+        case "languageId":
+            if (this._languageId !== update.languageId) {
+                this._languageId = update.languageId;
+                change.languageId = true;
+            }
+            break;
+        case "encoding":
+            if (this._encoding !== update.encoding) {
+                this._encoding = update.encoding;
+                change.encoding = true;
+            }
+            break;
+        case "EOL":
+            if (this._EOL !== update.EOL) {
+                this._EOL = update.EOL;
+                change.EOL = true;
+            }
+            break;
+        case "tabFocusMode":
+            if (this._tabFocusMode !== update.tabFocusMode) {
+                this._tabFocusMode = update.tabFocusMode;
+                change.tabFocusMode = true;
+            }
+            break;
+        case "inputMode":
+            if (this._inputMode !== update.inputMode) {
+                this._inputMode = update.inputMode;
+                change.inputMode = true;
+            }
+            break;
+        case "columnSelectionMode":
+            if (this._columnSelectionMode !== update.columnSelectionMode) {
+                this._columnSelectionMode = update.columnSelectionMode;
+                change.columnSelectionMode = true;
+            }
+            break;
+        case "metadata":
+            if (this._metadata !== update.metadata) {
+                this._metadata = update.metadata;
+                change.metadata = true;
+            }
+            break;
         }
         return change;
     }
@@ -235,40 +243,51 @@ let TabFocusMode = class TabFocusMode extends Disposable {
         this._onDidChange = this._register(( new Emitter()));
         this.onDidChange = this._onDidChange.event;
         this.registerListeners();
-        const tabFocusModeConfig = configurationService.getValue('editor.tabFocusMode') === true;
+        const tabFocusModeConfig = configurationService.getValue("editor.tabFocusMode") === true;
         TabFocus.setTabFocusMode(tabFocusModeConfig);
     }
     registerListeners() {
-        this._register(TabFocus.onDidChangeTabFocus(tabFocusMode => this._onDidChange.fire(tabFocusMode)));
+        this._register(
+            TabFocus.onDidChangeTabFocus(tabFocusMode => this._onDidChange.fire(tabFocusMode))
+        );
         this._register(this.configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration('editor.tabFocusMode')) {
-                const tabFocusModeConfig = this.configurationService.getValue('editor.tabFocusMode') === true;
+            if (e.affectsConfiguration("editor.tabFocusMode")) {
+                const tabFocusModeConfig = this.configurationService.getValue("editor.tabFocusMode") === true;
                 TabFocus.setTabFocusMode(tabFocusModeConfig);
                 this._onDidChange.fire(tabFocusModeConfig);
             }
         }));
     }
 };
-TabFocusMode = ( __decorate([
-    ( __param(0, IConfigurationService))
-], TabFocusMode));
+TabFocusMode = ( __decorate([( __param(0, IConfigurationService))], TabFocusMode));
 class StatusInputMode extends Disposable {
     constructor() {
         super();
         this._onDidChange = this._register(( new Emitter()));
         this.onDidChange = this._onDidChange.event;
-        InputMode.setInputMode('insert');
-        this._register(InputMode.onDidChangeInputMode(inputMode => this._onDidChange.fire(inputMode)));
+        InputMode.setInputMode("insert");
+        this._register(
+            InputMode.onDidChangeInputMode(inputMode => this._onDidChange.fire(inputMode))
+        );
     }
 }
-const nlsSingleSelectionRange = ( localize(3444, "Ln {0}, Col {1} ({2} selected)"));
-const nlsSingleSelection = ( localize(3445, "Ln {0}, Col {1}"));
-const nlsMultiSelectionRange = ( localize(3446, "{0} selections ({1} characters selected)"));
-const nlsMultiSelection = ( localize(3447, "{0} selections"));
-const nlsEOLLF = ( localize(3448, "LF"));
-const nlsEOLCRLF = ( localize(3449, "CRLF"));
+const nlsSingleSelectionRange = ( localize(3448, "Ln {0}, Col {1} ({2} selected)"));
+const nlsSingleSelection = ( localize(3449, "Ln {0}, Col {1}"));
+const nlsMultiSelectionRange = ( localize(3450, "{0} selections ({1} characters selected)"));
+const nlsMultiSelection = ( localize(3451, "{0} selections"));
+const nlsEOLLF = ( localize(3452, "LF"));
+const nlsEOLCRLF = ( localize(3453, "CRLF"));
 let EditorStatus = class EditorStatus extends Disposable {
-    constructor(targetWindowId, editorService, quickInputService, languageService, textFileService, statusbarService, instantiationService, configurationService) {
+    constructor(
+        targetWindowId,
+        editorService,
+        quickInputService,
+        languageService,
+        textFileService,
+        statusbarService,
+        instantiationService,
+        configurationService
+    ) {
         super();
         this.targetWindowId = targetWindowId;
         this.editorService = editorService;
@@ -290,7 +309,9 @@ let EditorStatus = class EditorStatus extends Disposable {
         this.toRender = undefined;
         this.activeEditorListeners = this._register(( new DisposableStore()));
         this.delayedRender = this._register(( new MutableDisposable()));
-        this.currentMarkerStatus = this._register(instantiationService.createInstance(ShowCurrentMarkerInStatusbarContribution));
+        this.currentMarkerStatus = this._register(
+            instantiationService.createInstance(ShowCurrentMarkerInStatusbarContribution)
+        );
         this.tabFocusMode = this._register(instantiationService.createInstance(TabFocusMode));
         this.inputMode = this._register(instantiationService.createInstance(StatusInputMode));
         this.registerCommands();
@@ -298,28 +319,41 @@ let EditorStatus = class EditorStatus extends Disposable {
     }
     registerListeners() {
         this._register(this.editorService.onDidActiveEditorChange(() => this.updateStatusBar()));
-        this._register(this.textFileService.untitled.onDidChangeEncoding(model => this.onResourceEncodingChange(model.resource)));
-        this._register(this.textFileService.files.onDidChangeEncoding(model => this.onResourceEncodingChange((model.resource))));
-        this._register(Event.runAndSubscribe(this.tabFocusMode.onDidChange, (tabFocusMode) => {
+        this._register(
+            this.textFileService.untitled.onDidChangeEncoding(model => this.onResourceEncodingChange(model.resource))
+        );
+        this._register(
+            this.textFileService.files.onDidChangeEncoding(model => this.onResourceEncodingChange((model.resource)))
+        );
+        this._register(Event.runAndSubscribe(this.tabFocusMode.onDidChange, tabFocusMode => {
             if (tabFocusMode !== undefined) {
                 this.onTabFocusModeChange(tabFocusMode);
-            }
-            else {
-                this.onTabFocusModeChange(this.configurationService.getValue('editor.tabFocusMode'));
+            } else {
+                this.onTabFocusModeChange(this.configurationService.getValue("editor.tabFocusMode"));
             }
         }));
-        this._register(Event.runAndSubscribe(this.inputMode.onDidChange, (inputMode) => this.onInputModeChange(inputMode ?? 'insert')));
+        this._register(Event.runAndSubscribe(
+            this.inputMode.onDidChange,
+            inputMode => this.onInputModeChange(inputMode ?? "insert")
+        ));
     }
     registerCommands() {
-        this._register(CommandsRegistry.registerCommand({ id: `changeEditorIndentation${this.targetWindowId}`, handler: () => this.showIndentationPicker() }));
+        this._register(CommandsRegistry.registerCommand({
+            id: `changeEditorIndentation${this.targetWindowId}`,
+            handler: () => this.showIndentationPicker()
+        }));
     }
     async showIndentationPicker() {
         const activeTextEditorControl = getCodeEditor(this.editorService.activeTextEditorControl);
         if (!activeTextEditorControl) {
-            return this.quickInputService.pick([{ label: ( localize(3450, "No text editor active at this time")) }]);
+            return this.quickInputService.pick([{
+                label: ( localize(3454, "No text editor active at this time"))
+            }]);
         }
         if (this.editorService.activeEditor?.isReadonly()) {
-            return this.quickInputService.pick([{ label: ( localize(3451, "The active code editor is read-only.")) }]);
+            return this.quickInputService.pick([{
+                label: ( localize(3455, "The active code editor is read-only."))
+            }]);
         }
         const picks = ( [
             assertReturnsDefined(activeTextEditorControl.getAction(IndentUsingSpaces.ID)),
@@ -329,7 +363,7 @@ let EditorStatus = class EditorStatus extends Disposable {
             assertReturnsDefined(activeTextEditorControl.getAction(IndentationToSpacesAction.ID)),
             assertReturnsDefined(activeTextEditorControl.getAction(IndentationToTabsAction.ID)),
             assertReturnsDefined(activeTextEditorControl.getAction(TrimTrailingWhitespaceAction.ID))
-        ].map((a) => {
+        ].map(a => {
             return {
                 id: a.id,
                 label: a.label,
@@ -340,63 +374,69 @@ let EditorStatus = class EditorStatus extends Disposable {
                 }
             };
         }));
-        picks.splice(3, 0, { type: 'separator', label: ( localize(3452, "convert file")) });
-        picks.unshift({ type: 'separator', label: ( localize(3453, "change view")) });
-        const action = await this.quickInputService.pick(picks, { placeHolder: ( localize(3454, "Select Action")), matchOnDetail: true });
+        picks.splice(3, 0, {
+            type: "separator",
+            label: ( localize(3456, "convert file"))
+        });
+        picks.unshift({
+            type: "separator",
+            label: ( localize(3457, "change view"))
+        });
+        const action = await this.quickInputService.pick(picks, {
+            placeHolder: ( localize(3458, "Select Action")),
+            matchOnDetail: true
+        });
         return action?.run();
     }
     updateTabFocusModeElement(visible) {
         if (visible) {
             if (!this.tabFocusModeElement.value) {
-                const text = ( localize(3455, "Tab Moves Focus"));
+                const text = ( localize(3459, "Tab Moves Focus"));
                 this.tabFocusModeElement.value = this.statusbarService.addEntry({
-                    name: ( localize(3456, "Accessibility Mode")),
+                    name: ( localize(3460, "Accessibility Mode")),
                     text,
                     ariaLabel: text,
-                    tooltip: ( localize(3457, "Disable Accessibility Mode")),
-                    command: 'editor.action.toggleTabFocusMode',
-                    kind: 'prominent'
-                }, 'status.editor.tabFocusMode', StatusbarAlignment.RIGHT, 100.7);
+                    tooltip: ( localize(3461, "Disable Accessibility Mode")),
+                    command: "editor.action.toggleTabFocusMode",
+                    kind: "prominent"
+                }, "status.editor.tabFocusMode", StatusbarAlignment.RIGHT, 100.7);
             }
-        }
-        else {
+        } else {
             this.tabFocusModeElement.clear();
         }
     }
     updateInputModeElement(inputMode) {
-        if (inputMode === 'overtype') {
+        if (inputMode === "overtype") {
             if (!this.inputModeElement.value) {
-                const text = ( localize(3458, 'OVR'));
-                const name = ( localize(3459, "Enable Insert Mode"));
+                const text = ( localize(3462, "OVR"));
+                const name = ( localize(3463, "Enable Insert Mode"));
                 this.inputModeElement.value = this.statusbarService.addEntry({
                     name,
                     text,
                     ariaLabel: text,
                     tooltip: name,
-                    command: 'editor.action.toggleOvertypeInsertMode',
-                    kind: 'prominent'
-                }, 'status.editor.inputMode', StatusbarAlignment.RIGHT, 100.6);
+                    command: "editor.action.toggleOvertypeInsertMode",
+                    kind: "prominent"
+                }, "status.editor.inputMode", StatusbarAlignment.RIGHT, 100.6);
             }
-        }
-        else {
+        } else {
             this.inputModeElement.clear();
         }
     }
     updateColumnSelectionModeElement(visible) {
         if (visible) {
             if (!this.columnSelectionModeElement.value) {
-                const text = ( localize(3460, "Column Selection"));
+                const text = ( localize(3464, "Column Selection"));
                 this.columnSelectionModeElement.value = this.statusbarService.addEntry({
-                    name: ( localize(3461, "Column Selection Mode")),
+                    name: ( localize(3465, "Column Selection Mode")),
                     text,
                     ariaLabel: text,
-                    tooltip: ( localize(3462, "Disable Column Selection Mode")),
-                    command: 'editor.action.toggleColumnSelection',
-                    kind: 'prominent'
-                }, 'status.editor.columnSelectionMode', StatusbarAlignment.RIGHT, 100.8);
+                    tooltip: ( localize(3466, "Disable Column Selection Mode")),
+                    command: "editor.action.toggleColumnSelection",
+                    kind: "prominent"
+                }, "status.editor.columnSelectionMode", StatusbarAlignment.RIGHT, 100.8);
             }
-        }
-        else {
+        } else {
             this.columnSelectionModeElement.clear();
         }
     }
@@ -411,13 +451,19 @@ let EditorStatus = class EditorStatus extends Disposable {
             return;
         }
         const props = {
-            name: ( localize(3463, "Editor Selection")),
+            name: ( localize(3467, "Editor Selection")),
             text,
             ariaLabel: text,
-            tooltip: ( localize(3464, "Go to Line/Column")),
-            command: 'workbench.action.gotoLine'
+            tooltip: ( localize(3468, "Go to Line/Column")),
+            command: "workbench.action.gotoLine"
         };
-        this.updateElement(this.selectionElement, props, 'status.editor.selection', StatusbarAlignment.RIGHT, 100.5);
+        this.updateElement(
+            this.selectionElement,
+            props,
+            "status.editor.selection",
+            StatusbarAlignment.RIGHT,
+            100.5
+        );
     }
     updateIndentationElement(text) {
         if (!text) {
@@ -430,13 +476,19 @@ let EditorStatus = class EditorStatus extends Disposable {
             return;
         }
         const props = {
-            name: ( localize(3465, "Editor Indentation")),
+            name: ( localize(3469, "Editor Indentation")),
             text,
             ariaLabel: text,
-            tooltip: ( localize(3466, "Select Indentation")),
+            tooltip: ( localize(3470, "Select Indentation")),
             command: `changeEditorIndentation${this.targetWindowId}`
         };
-        this.updateElement(this.indentationElement, props, 'status.editor.indentation', StatusbarAlignment.RIGHT, 100.4);
+        this.updateElement(
+            this.indentationElement,
+            props,
+            "status.editor.indentation",
+            StatusbarAlignment.RIGHT,
+            100.4
+        );
     }
     updateEncodingElement(text) {
         if (!text) {
@@ -444,13 +496,19 @@ let EditorStatus = class EditorStatus extends Disposable {
             return;
         }
         const props = {
-            name: ( localize(3467, "Editor Encoding")),
+            name: ( localize(3471, "Editor Encoding")),
             text,
             ariaLabel: text,
-            tooltip: ( localize(3468, "Select Encoding")),
-            command: 'workbench.action.editor.changeEncoding'
+            tooltip: ( localize(3472, "Select Encoding")),
+            command: "workbench.action.editor.changeEncoding"
         };
-        this.updateElement(this.encodingElement, props, 'status.editor.encoding', StatusbarAlignment.RIGHT, 100.3);
+        this.updateElement(
+            this.encodingElement,
+            props,
+            "status.editor.encoding",
+            StatusbarAlignment.RIGHT,
+            100.3
+        );
     }
     updateEOLElement(text) {
         if (!text) {
@@ -458,13 +516,19 @@ let EditorStatus = class EditorStatus extends Disposable {
             return;
         }
         const props = {
-            name: ( localize(3469, "Editor End of Line")),
+            name: ( localize(3473, "Editor End of Line")),
             text,
             ariaLabel: text,
-            tooltip: ( localize(3470, "Select End of Line Sequence")),
-            command: 'workbench.action.editor.changeEOL'
+            tooltip: ( localize(3474, "Select End of Line Sequence")),
+            command: "workbench.action.editor.changeEOL"
         };
-        this.updateElement(this.eolElement, props, 'status.editor.eol', StatusbarAlignment.RIGHT, 100.2);
+        this.updateElement(
+            this.eolElement,
+            props,
+            "status.editor.eol",
+            StatusbarAlignment.RIGHT,
+            100.2
+        );
     }
     updateLanguageIdElement(text) {
         if (!text) {
@@ -472,13 +536,19 @@ let EditorStatus = class EditorStatus extends Disposable {
             return;
         }
         const props = {
-            name: ( localize(3471, "Editor Language")),
+            name: ( localize(3475, "Editor Language")),
             text,
             ariaLabel: text,
-            tooltip: ( localize(3472, "Select Language Mode")),
-            command: 'workbench.action.editor.changeLanguageMode'
+            tooltip: ( localize(3476, "Select Language Mode")),
+            command: "workbench.action.editor.changeLanguageMode"
         };
-        this.updateElement(this.languageElement, props, 'status.editor.mode', StatusbarAlignment.RIGHT, 100.1);
+        this.updateElement(
+            this.languageElement,
+            props,
+            "status.editor.mode",
+            StatusbarAlignment.RIGHT,
+            100.1
+        );
     }
     updateMetadataElement(text) {
         if (!text) {
@@ -486,18 +556,23 @@ let EditorStatus = class EditorStatus extends Disposable {
             return;
         }
         const props = {
-            name: ( localize(3473, "File Information")),
+            name: ( localize(3477, "File Information")),
             text,
             ariaLabel: text,
-            tooltip: ( localize(3474, "File Information"))
+            tooltip: ( localize(3478, "File Information"))
         };
-        this.updateElement(this.metadataElement, props, 'status.editor.info', StatusbarAlignment.RIGHT, 100);
+        this.updateElement(
+            this.metadataElement,
+            props,
+            "status.editor.info",
+            StatusbarAlignment.RIGHT,
+            100
+        );
     }
     updateElement(element, props, id, alignment, priority) {
         if (!element.value) {
             element.value = this.statusbarService.addEntry(props, id, alignment, priority);
-        }
-        else {
+        } else {
             element.value.update(props);
         }
     }
@@ -516,8 +591,7 @@ let EditorStatus = class EditorStatus extends Disposable {
                     this.doRenderNow();
                 }
             });
-        }
-        else {
+        } else {
             this.toRender.combine(changed);
         }
     }
@@ -528,7 +602,9 @@ let EditorStatus = class EditorStatus extends Disposable {
         this.updateIndentationElement(this.state.indentation);
         this.updateSelectionElement(this.state.selectionStatus);
         this.updateEncodingElement(this.state.encoding);
-        this.updateEOLElement(this.state.EOL ? this.state.EOL === '\r\n' ? nlsEOLCRLF : nlsEOLLF : undefined);
+        this.updateEOLElement(
+            this.state.EOL ? this.state.EOL === "\r\n" ? nlsEOLCRLF : nlsEOLLF : undefined
+        );
         this.updateLanguageIdElement(this.state.languageId);
         this.updateMetadataElement(this.state.metadata);
     }
@@ -538,9 +614,18 @@ let EditorStatus = class EditorStatus extends Disposable {
         }
         if (info.selections.length === 1) {
             if (info.charactersSelected) {
-                return format(nlsSingleSelectionRange, info.selections[0].positionLineNumber, info.selections[0].positionColumn, info.charactersSelected);
+                return format(
+                    nlsSingleSelectionRange,
+                    info.selections[0].positionLineNumber,
+                    info.selections[0].positionColumn,
+                    info.charactersSelected
+                );
             }
-            return format(nlsSingleSelection, info.selections[0].positionLineNumber, info.selections[0].positionColumn);
+            return format(
+                nlsSingleSelection,
+                info.selections[0].positionLineNumber,
+                info.selections[0].positionColumn
+            );
         }
         if (info.charactersSelected) {
             return format(nlsMultiSelectionRange, info.selections.length, info.charactersSelected);
@@ -569,7 +654,7 @@ let EditorStatus = class EditorStatus extends Disposable {
             }));
         }
         if (activeCodeEditor) {
-            this.activeEditorListeners.add(activeCodeEditor.onDidChangeConfiguration((event) => {
+            this.activeEditorListeners.add(activeCodeEditor.onDidChangeConfiguration(event => {
                 if (event.hasChanged(EditorOption.columnSelection)) {
                     this.onColumnSelectionModeChange(activeCodeEditor);
                 }
@@ -611,8 +696,7 @@ let EditorStatus = class EditorStatus extends Disposable {
                 if (secondary instanceof BaseBinaryResourceEditor) {
                     binaryEditors.push(secondary);
                 }
-            }
-            else {
+            } else {
                 binaryEditors.push(activeEditorPane);
             }
             for (const editor of binaryEditors) {
@@ -626,7 +710,10 @@ let EditorStatus = class EditorStatus extends Disposable {
         }
     }
     onLanguageChange(editorWidget, editorInput) {
-        const info = { type: 'languageId', languageId: undefined };
+        const info = {
+            type: "languageId",
+            languageId: undefined
+        };
         if (editorWidget && editorInput && toEditorWithLanguageSupport(editorInput)) {
             const textModel = editorWidget.getModel();
             if (textModel) {
@@ -637,34 +724,39 @@ let EditorStatus = class EditorStatus extends Disposable {
         this.updateState(info);
     }
     onIndentationChange(editorWidget) {
-        const update = { type: 'indentation', indentation: undefined };
+        const update = {
+            type: "indentation",
+            indentation: undefined
+        };
         if (editorWidget) {
             const model = editorWidget.getModel();
             if (model) {
                 const modelOpts = model.getOptions();
-                update.indentation = (modelOpts.insertSpaces
-                    ? modelOpts.tabSize === modelOpts.indentSize
-                        ? ( localize(3475, "Spaces: {0}", modelOpts.indentSize))
-                        : ( localize(
-                    3476,
+                update.indentation = (modelOpts.insertSpaces ? modelOpts.tabSize === modelOpts.indentSize ? ( localize(3479, "Spaces: {0}", modelOpts.indentSize)) : ( localize(
+                    3480,
                     "Spaces: {0} (Tab Size: {1})",
                     modelOpts.indentSize,
                     modelOpts.tabSize
-                ))
-                    : ( localize(3477, "Tab Size: {0}", modelOpts.tabSize)));
+                )) : ( localize(3481, "Tab Size: {0}", modelOpts.tabSize)));
             }
         }
         this.updateState(update);
     }
     onMetadataChange(editor) {
-        const update = { type: 'metadata', metadata: undefined };
+        const update = {
+            type: "metadata",
+            metadata: undefined
+        };
         if (editor instanceof BaseBinaryResourceEditor || editor instanceof BinaryResourceDiffEditor) {
             update.metadata = editor.getMetadata();
         }
         this.updateState(update);
     }
     onColumnSelectionModeChange(editorWidget) {
-        const info = { type: 'columnSelectionMode', columnSelectionMode: false };
+        const info = {
+            type: "columnSelectionMode",
+            columnSelectionMode: false
+        };
         if (editorWidget?.getOption(EditorOption.columnSelection)) {
             info.columnSelectionMode = true;
         }
@@ -678,7 +770,7 @@ let EditorStatus = class EditorStatus extends Disposable {
             const textModel = editorWidget.getModel();
             if (textModel) {
                 for (const selection of info.selections) {
-                    if (typeof info.charactersSelected !== 'number') {
+                    if (typeof info.charactersSelected !== "number") {
                         info.charactersSelected = 0;
                     }
                     info.charactersSelected += textModel.getCharacterCountInRange(selection);
@@ -695,10 +787,16 @@ let EditorStatus = class EditorStatus extends Disposable {
                 info.selections[0] = selectionClone;
             }
         }
-        this.updateState({ type: 'selectionStatus', selectionStatus: this.getSelectionLabel(info) });
+        this.updateState({
+            type: "selectionStatus",
+            selectionStatus: this.getSelectionLabel(info)
+        });
     }
     onEOLChange(editorWidget) {
-        const info = { type: 'EOL', EOL: undefined };
+        const info = {
+            type: "EOL",
+            EOL: undefined
+        };
         if (editorWidget && !editorWidget.getOption(EditorOption.readOnly)) {
             const codeEditorModel = editorWidget.getModel();
             if (codeEditorModel) {
@@ -711,16 +809,18 @@ let EditorStatus = class EditorStatus extends Disposable {
         if (editor && !this.isActiveEditor(editor)) {
             return;
         }
-        const info = { type: 'encoding', encoding: undefined };
+        const info = {
+            type: "encoding",
+            encoding: undefined
+        };
         if (editor && editorWidget?.hasModel()) {
             const encodingSupport = editor.input ? toEditorWithEncodingSupport(editor.input) : null;
             if (encodingSupport) {
                 const rawEncoding = encodingSupport.getEncoding();
-                const encodingInfo = typeof rawEncoding === 'string' ? SUPPORTED_ENCODINGS[rawEncoding] : undefined;
+                const encodingInfo = typeof rawEncoding === "string" ? SUPPORTED_ENCODINGS[rawEncoding] : undefined;
                 if (encodingInfo) {
                     info.encoding = encodingInfo.labelShort;
-                }
-                else {
+                } else {
                     info.encoding = rawEncoding;
                 }
             }
@@ -730,7 +830,9 @@ let EditorStatus = class EditorStatus extends Disposable {
     onResourceEncodingChange(resource) {
         const activeEditorPane = this.editorService.activeEditorPane;
         if (activeEditorPane) {
-            const activeResource = EditorResourceAccessor.getCanonicalUri(activeEditorPane.input, { supportSideBySide: SideBySideEditor.PRIMARY });
+            const activeResource = EditorResourceAccessor.getCanonicalUri(activeEditorPane.input, {
+                supportSideBySide: SideBySideEditor.PRIMARY
+            });
             if (activeResource && isEqual(activeResource, resource)) {
                 const activeCodeEditor = getCodeEditor(activeEditorPane.getControl()) ?? undefined;
                 return this.onEncodingChange(activeEditorPane, activeCodeEditor);
@@ -738,11 +840,17 @@ let EditorStatus = class EditorStatus extends Disposable {
         }
     }
     onTabFocusModeChange(tabFocusMode) {
-        const info = { type: 'tabFocusMode', tabFocusMode };
+        const info = {
+            type: "tabFocusMode",
+            tabFocusMode
+        };
         this.updateState(info);
     }
     onInputModeChange(inputMode) {
-        const info = { type: 'inputMode', inputMode };
+        const info = {
+            type: "inputMode",
+            inputMode
+        };
         this.updateState(info);
     }
     isActiveEditor(control) {
@@ -750,24 +858,20 @@ let EditorStatus = class EditorStatus extends Disposable {
         return !!activeEditorPane && activeEditorPane === control;
     }
 };
-EditorStatus = ( __decorate([
-    ( __param(1, IEditorService)),
-    ( __param(2, IQuickInputService)),
-    ( __param(3, ILanguageService)),
-    ( __param(4, ITextFileService)),
-    ( __param(5, IStatusbarService)),
-    ( __param(6, IInstantiationService)),
-    ( __param(7, IConfigurationService))
-], EditorStatus));
+EditorStatus = ( __decorate([( __param(1, IEditorService)), ( __param(2, IQuickInputService)), ( __param(3, ILanguageService)), ( __param(4, ITextFileService)), ( __param(5, IStatusbarService)), ( __param(6, IInstantiationService)), ( __param(7, IConfigurationService))], EditorStatus));
 let EditorStatusContribution = class EditorStatusContribution extends Disposable {
-    static { this.ID = 'workbench.contrib.editorStatus'; }
+    static {
+        this.ID = "workbench.contrib.editorStatus";
+    }
     constructor(editorGroupService) {
         super();
         this.editorGroupService = editorGroupService;
         for (const part of editorGroupService.parts) {
             this.createEditorStatus(part);
         }
-        this._register(editorGroupService.onDidCreateAuxiliaryEditorPart(part => this.createEditorStatus(part)));
+        this._register(
+            editorGroupService.onDidCreateAuxiliaryEditorPart(part => this.createEditorStatus(part))
+        );
     }
     createEditorStatus(part) {
         const disposables = ( new DisposableStore());
@@ -776,9 +880,7 @@ let EditorStatusContribution = class EditorStatusContribution extends Disposable
         disposables.add(scopedInstantiationService.createInstance(EditorStatus, part.windowId));
     }
 };
-EditorStatusContribution = ( __decorate([
-    ( __param(0, IEditorGroupsService))
-], EditorStatusContribution));
+EditorStatusContribution = ( __decorate([( __param(0, IEditorGroupsService))], EditorStatusContribution));
 let ShowCurrentMarkerInStatusbarContribution = class ShowCurrentMarkerInStatusbarContribution extends Disposable {
     constructor(statusbarService, markerService, configurationService) {
         super();
@@ -789,8 +891,13 @@ let ShowCurrentMarkerInStatusbarContribution = class ShowCurrentMarkerInStatusba
         this.markers = [];
         this.currentMarker = null;
         this.statusBarEntryAccessor = this._register(( new MutableDisposable()));
-        this._register(markerService.onMarkerChanged(changedResources => this.onMarkerChanged(changedResources)));
-        this._register(Event.filter(configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('problems.showCurrentInStatus'))(() => this.updateStatus()));
+        this._register(
+            markerService.onMarkerChanged(changedResources => this.onMarkerChanged(changedResources))
+        );
+        this._register(Event.filter(
+            configurationService.onDidChangeConfiguration,
+            e => e.affectsConfiguration("problems.showCurrentInStatus")
+        )(() => this.updateStatus()));
     }
     update(editor) {
         this.editor = editor;
@@ -805,13 +912,19 @@ let ShowCurrentMarkerInStatusbarContribution = class ShowCurrentMarkerInStatusba
                 const line = splitLines(this.currentMarker.message)[0];
                 const text = `${this.getType(this.currentMarker)} ${line}`;
                 if (!this.statusBarEntryAccessor.value) {
-                    this.statusBarEntryAccessor.value = this.statusbarService.addEntry({ name: ( localize(3478, "Current Problem")), text, ariaLabel: text }, 'statusbar.currentProblem', StatusbarAlignment.LEFT);
-                }
-                else {
-                    this.statusBarEntryAccessor.value.update({ name: ( localize(3478, "Current Problem")), text, ariaLabel: text });
+                    this.statusBarEntryAccessor.value = this.statusbarService.addEntry({
+                        name: ( localize(3482, "Current Problem")),
+                        text,
+                        ariaLabel: text
+                    }, "statusbar.currentProblem", StatusbarAlignment.LEFT);
+                } else {
+                    this.statusBarEntryAccessor.value.update({
+                        name: ( localize(3482, "Current Problem")),
+                        text,
+                        ariaLabel: text
+                    });
                 }
-            }
-            else {
+            } else {
                 this.statusBarEntryAccessor.clear();
             }
         }
@@ -827,14 +940,17 @@ let ShowCurrentMarkerInStatusbarContribution = class ShowCurrentMarkerInStatusba
     }
     getType(marker) {
         switch (marker.severity) {
-            case MarkerSeverity.Error: return '$(error)';
-            case MarkerSeverity.Warning: return '$(warning)';
-            case MarkerSeverity.Info: return '$(info)';
+        case MarkerSeverity.Error:
+            return "$(error)";
+        case MarkerSeverity.Warning:
+            return "$(warning)";
+        case MarkerSeverity.Info:
+            return "$(info)";
         }
-        return '';
+        return "";
     }
     getMarker() {
-        if (!this.configurationService.getValue('problems.showCurrentInStatus')) {
+        if (!this.configurationService.getValue("problems.showCurrentInStatus")) {
             return null;
         }
         if (!this.editor) {
@@ -877,8 +993,7 @@ let ShowCurrentMarkerInStatusbarContribution = class ShowCurrentMarkerInStatusba
                 severities: MarkerSeverity.Error | MarkerSeverity.Warning | MarkerSeverity.Info
             });
             this.markers.sort(this.compareMarker);
-        }
-        else {
+        } else {
             this.markers = [];
         }
         this.updateStatus();
@@ -894,48 +1009,27 @@ let ShowCurrentMarkerInStatusbarContribution = class ShowCurrentMarkerInStatusba
         return res;
     }
 };
-ShowCurrentMarkerInStatusbarContribution = ( __decorate([
-    ( __param(0, IStatusbarService)),
-    ( __param(1, IMarkerService)),
-    ( __param(2, IConfigurationService))
-], ShowCurrentMarkerInStatusbarContribution));
-let ShowLanguageExtensionsAction = class ShowLanguageExtensionsAction extends Action {
-    static { ShowLanguageExtensionsAction_1 = this; }
-    static { this.ID = 'workbench.action.showLanguageExtensions'; }
-    constructor(fileExtension, commandService, galleryService) {
-        super(ShowLanguageExtensionsAction_1.ID, ( localize(3479, "Search Marketplace Extensions for '{0}'...", fileExtension)));
-        this.fileExtension = fileExtension;
-        this.commandService = commandService;
-        this.enabled = galleryService.isEnabled();
-    }
-    async run() {
-        await this.commandService.executeCommand('workbench.extensions.action.showExtensionsForLanguage', this.fileExtension);
-    }
-};
-ShowLanguageExtensionsAction = ShowLanguageExtensionsAction_1 = ( __decorate([
-    ( __param(1, ICommandService)),
-    ( __param(2, IExtensionGalleryService))
-], ShowLanguageExtensionsAction));
+ShowCurrentMarkerInStatusbarContribution = ( __decorate([( __param(0, IStatusbarService)), ( __param(1, IMarkerService)), ( __param(2, IConfigurationService))], ShowCurrentMarkerInStatusbarContribution));
 class ChangeLanguageAction extends Action2 {
-    static { this.ID = 'workbench.action.editor.changeLanguageMode'; }
+    static {
+        this.ID = "workbench.action.editor.changeLanguageMode";
+    }
     constructor() {
         super({
             id: ChangeLanguageAction.ID,
-            title: ( localize2(3480, 'Change Language Mode')),
+            title: ( localize2(3483, "Change Language Mode")),
             f1: true,
             keybinding: {
                 weight: KeybindingWeight.WorkbenchContrib,
                 primary: KeyChord(KeyMod$1.CtrlCmd | KeyCode.KeyK, KeyCode.KeyM)
             },
-            precondition: ContextKeyExpr.not('notebookEditorFocused'),
+            precondition: ContextKeyExpr.not("notebookEditorFocused"),
             metadata: {
-                description: ( localize(3481, "Change the language mode of the active text editor.")),
-                args: [
-                    {
-                        name: ( localize(3482, "The name of the language mode to change to.")),
-                        constraint: (value) => typeof value === 'string',
-                    }
-                ]
+                description: ( localize(3484, "Change the language mode of the active text editor.")),
+                args: [{
+                    name: ( localize(3485, "The name of the language mode to change to.")),
+                    constraint: value => typeof value === "string"
+                }]
             }
         });
     }
@@ -946,16 +1040,21 @@ class ChangeLanguageAction extends Action2 {
         const languageDetectionService = accessor.get(ILanguageDetectionService);
         const textFileService = accessor.get(ITextFileService);
         const preferencesService = accessor.get(IPreferencesService);
-        const instantiationService = accessor.get(IInstantiationService);
         const configurationService = accessor.get(IConfigurationService);
         const telemetryService = accessor.get(ITelemetryService);
+        const commandService = accessor.get(ICommandService);
+        const galleryService = accessor.get(IExtensionGalleryService);
         const activeTextEditorControl = getCodeEditor(editorService.activeTextEditorControl);
         if (!activeTextEditorControl) {
-            await quickInputService.pick([{ label: ( localize(3450, "No text editor active at this time")) }]);
+            await quickInputService.pick([{
+                label: ( localize(3454, "No text editor active at this time"))
+            }]);
             return;
         }
         const textModel = activeTextEditorControl.getModel();
-        const resource = EditorResourceAccessor.getOriginalUri(editorService.activeEditor, { supportSideBySide: SideBySideEditor.PRIMARY });
+        const resource = EditorResourceAccessor.getOriginalUri(editorService.activeEditor, {
+            supportSideBySide: SideBySideEditor.PRIMARY
+        });
         let currentLanguageName;
         let currentLanguageId;
         if (textModel) {
@@ -967,43 +1066,65 @@ class ChangeLanguageAction extends Action2 {
             hasLanguageSupport = false;
         }
         const languages = languageService.getSortedRegisteredLanguageNames();
-        const picks = ( languages
-            .map(({ languageName, languageId }) => {
-            const extensions = languageService.getExtensions(languageId).join(' ');
+        const picks = ( languages.map((
+            {
+                languageName,
+                languageId
+            }
+        ) => {
+            const extensions = languageService.getExtensions(languageId).join(" ");
             let description;
             if (currentLanguageName === languageName) {
-                description = ( localize(3483, "({0}) - Configured Language", languageId));
-            }
-            else {
-                description = ( localize(3484, "({0})", languageId));
+                description = ( localize(3486, "({0}) - Configured Language", languageId));
+            } else {
+                description = ( localize(3487, "({0})", languageId));
             }
             return {
+                id: languageId,
                 label: languageName,
                 meta: extensions,
                 iconClasses: getIconClassesForLanguageId(languageId),
                 description
             };
         }));
-        picks.unshift({ type: 'separator', label: ( localize(3485, "languages (identifier)")) });
+        picks.unshift({
+            type: "separator",
+            label: ( localize(3488, "languages (identifier)"))
+        });
         let configureLanguageAssociations;
         let configureLanguageSettings;
         let galleryAction;
         if (hasLanguageSupport && resource) {
             const ext = extname(resource) || basename(resource);
-            galleryAction = instantiationService.createInstance(ShowLanguageExtensionsAction, ext);
-            if (galleryAction.enabled) {
+            if (galleryService.isEnabled()) {
+                galleryAction = toAction({
+                    id: "workbench.action.showLanguageExtensions",
+                    label: ( localize(3489, "Search Marketplace Extensions for '{0}'...", ext)),
+                    run: () => commandService.executeCommand("workbench.extensions.action.showExtensionsForLanguage", ext)
+                });
                 picks.unshift(galleryAction);
             }
-            configureLanguageSettings = { label: ( localize(3486, "Configure '{0}' language based settings...", currentLanguageName)) };
+            configureLanguageSettings = {
+                label: ( localize(3490, "Configure '{0}' language based settings...", currentLanguageName))
+            };
             picks.unshift(configureLanguageSettings);
-            configureLanguageAssociations = { label: ( localize(3487, "Configure File Association for '{0}'...", ext)) };
+            configureLanguageAssociations = {
+                label: ( localize(3491, "Configure File Association for '{0}'...", ext))
+            };
             picks.unshift(configureLanguageAssociations);
         }
-        const autoDetectLanguage = { label: ( localize(3488, "Auto Detect")) };
+        const autoDetectLanguage = {
+            label: ( localize(3492, "Auto Detect"))
+        };
         if (textModel && textModel.getValueLength() > 0) {
             picks.unshift(autoDetectLanguage);
         }
-        const pick = typeof languageMode === 'string' ? { label: languageMode } : await quickInputService.pick(picks, { placeHolder: ( localize(3489, "Select Language Mode")), matchOnDescription: true });
+        const pick = typeof languageMode === "string" ? {
+            label: languageMode
+        } : await quickInputService.pick(picks, {
+            placeHolder: ( localize(3493, "Select Language Mode")),
+            matchOnDescription: true
+        });
         if (!pick) {
             return;
         }
@@ -1018,7 +1139,13 @@ class ChangeLanguageAction extends Action2 {
             return;
         }
         if (pick === configureLanguageSettings) {
-            preferencesService.openUserSettings({ jsonEditor: true, revealSetting: { key: `[${currentLanguageId ?? null}]`, edit: true } });
+            preferencesService.openUserSettings({
+                jsonEditor: true,
+                revealSetting: {
+                    key: `[${currentLanguageId ?? null}]`,
+                    edit: true
+                }
+            });
             return;
         }
         const activeEditor = editorService.activeEditor;
@@ -1029,10 +1156,12 @@ class ChangeLanguageAction extends Action2 {
                 let detectedLanguage;
                 if (pick === autoDetectLanguage) {
                     if (textModel) {
-                        const resource = EditorResourceAccessor.getOriginalUri(activeEditor, { supportSideBySide: SideBySideEditor.PRIMARY });
+                        const resource = EditorResourceAccessor.getOriginalUri(activeEditor, {
+                            supportSideBySide: SideBySideEditor.PRIMARY
+                        });
                         if (resource) {
                             let languageId = languageService.guessLanguageIdByFilepathOrFirstLine(resource, textModel.getLineContent(1)) ?? undefined;
-                            if (!languageId || languageId === 'unknown') {
+                            if (!languageId || languageId === "unknown") {
                                 detectedLanguage = await languageDetectionService.detectLanguage(resource);
                                 languageId = detectedLanguage;
                             }
@@ -1041,33 +1170,31 @@ class ChangeLanguageAction extends Action2 {
                             }
                         }
                     }
-                }
-                else {
-                    const languageId = languageService.getLanguageIdByLanguageName(pick.label);
-                    languageSelection = languageService.createById(languageId);
+                } else {
+                    languageSelection = languageService.createById(pick.id);
                     if (resource) {
                         languageDetectionService.detectLanguage(resource).then(detectedLanguageId => {
-                            const chosenLanguageId = languageService.getLanguageIdByLanguageName(pick.label) || 'unknown';
+                            const chosenLanguageId = languageService.getLanguageIdByLanguageName(pick.label) || "unknown";
                             if (detectedLanguageId === currentLanguageId && currentLanguageId !== chosenLanguageId) {
-                                const modelPreference = configurationService.getValue('workbench.editor.preferHistoryBasedLanguageDetection') ? 'history' : 'classic';
+                                const modelPreference = configurationService.getValue("workbench.editor.preferHistoryBasedLanguageDetection") ? "history" : "classic";
                                 telemetryService.publicLog2(AutomaticLanguageDetectionLikelyWrongId, {
-                                    currentLanguageId: currentLanguageName ?? 'unknown',
+                                    currentLanguageId: currentLanguageName ?? "unknown",
                                     nextLanguageId: pick.label,
                                     lineCount: textModel?.getLineCount() ?? -1,
-                                    modelPreference,
+                                    modelPreference
                                 });
                             }
                         });
                     }
                 }
-                if (typeof languageSelection !== 'undefined') {
+                if (typeof languageSelection !== "undefined") {
                     languageSupport.setLanguageId(languageSelection.languageId, ChangeLanguageAction.ID);
                     if (resource?.scheme === Schemas.untitled) {
-                        const modelPreference = configurationService.getValue('workbench.editor.preferHistoryBasedLanguageDetection') ? 'history' : 'classic';
-                        telemetryService.publicLog2('setUntitledDocumentLanguage', {
+                        const modelPreference = configurationService.getValue("workbench.editor.preferHistoryBasedLanguageDetection") ? "history" : "classic";
+                        telemetryService.publicLog2("setUntitledDocumentLanguage", {
                             to: languageSelection.languageId,
-                            from: currentLanguageId ?? 'none',
-                            modelPreference,
+                            from: currentLanguageId ?? "none",
+                            modelPreference
                         });
                     }
                 }
@@ -1080,30 +1207,38 @@ class ChangeLanguageAction extends Action2 {
         const base = basename(resource);
         const currentAssociation = languageService.guessLanguageIdByFilepathOrFirstLine(URI.file(base));
         const languages = languageService.getSortedRegisteredLanguageNames();
-        const picks = ( languages.map(({ languageName, languageId }) => {
+        const picks = ( languages.map((
+            {
+                languageName,
+                languageId
+            }
+        ) => {
             return {
                 id: languageId,
                 label: languageName,
                 iconClasses: getIconClassesForLanguageId(languageId),
-                description: (languageId === currentAssociation) ? ( localize(3490, "Current Association")) : undefined
+                description: (languageId === currentAssociation) ? ( localize(3494, "Current Association")) : undefined
             };
         }));
         setTimeout(async () => {
-            const language = await quickInputService.pick(picks, { placeHolder: ( localize(3491, "Select Language Mode to Associate with '{0}'", extension || base)) });
+            const language = await quickInputService.pick(picks, {
+                placeHolder: ( localize(3495, "Select Language Mode to Associate with '{0}'", extension || base))
+            });
             if (language) {
                 const fileAssociationsConfig = configurationService.inspect(FILES_ASSOCIATIONS_CONFIG);
                 let associationKey;
-                if (extension && base[0] !== '.') {
+                if (extension && base[0] !== ".") {
                     associationKey = `*${extension}`;
-                }
-                else {
+                } else {
                     associationKey = base;
                 }
                 let target = ConfigurationTarget.USER;
                 if (fileAssociationsConfig.workspaceValue?.[associationKey]) {
                     target = ConfigurationTarget.WORKSPACE;
                 }
-                const currentAssociations = deepClone((target === ConfigurationTarget.WORKSPACE) ? fileAssociationsConfig.workspaceValue : fileAssociationsConfig.userValue) || Object.create(null);
+                const currentAssociations = deepClone(
+                    (target === ConfigurationTarget.WORKSPACE) ? fileAssociationsConfig.workspaceValue : fileAssociationsConfig.userValue
+                ) || Object.create(null);
                 currentAssociations[associationKey] = language.id;
                 configurationService.updateValue(FILES_ASSOCIATIONS_CONFIG, currentAssociations, target);
             }
@@ -1113,8 +1248,8 @@ class ChangeLanguageAction extends Action2 {
 class ChangeEOLAction extends Action2 {
     constructor() {
         super({
-            id: 'workbench.action.editor.changeEOL',
-            title: ( localize2(3492, 'Change End of Line Sequence')),
+            id: "workbench.action.editor.changeEOL",
+            title: ( localize2(3496, "Change End of Line Sequence")),
             f1: true
         });
     }
@@ -1123,20 +1258,30 @@ class ChangeEOLAction extends Action2 {
         const quickInputService = accessor.get(IQuickInputService);
         const activeTextEditorControl = getCodeEditor(editorService.activeTextEditorControl);
         if (!activeTextEditorControl) {
-            await quickInputService.pick([{ label: ( localize(3450, "No text editor active at this time")) }]);
+            await quickInputService.pick([{
+                label: ( localize(3454, "No text editor active at this time"))
+            }]);
             return;
         }
         if (editorService.activeEditor?.isReadonly()) {
-            await quickInputService.pick([{ label: ( localize(3451, "The active code editor is read-only.")) }]);
+            await quickInputService.pick([{
+                label: ( localize(3455, "The active code editor is read-only."))
+            }]);
             return;
         }
         let textModel = activeTextEditorControl.getModel();
-        const EOLOptions = [
-            { label: nlsEOLLF, eol: EndOfLineSequence.LF },
-            { label: nlsEOLCRLF, eol: EndOfLineSequence.CRLF },
-        ];
-        const selectedIndex = (textModel?.getEOL() === '\n') ? 0 : 1;
-        const eol = await quickInputService.pick(EOLOptions, { placeHolder: ( localize(3493, "Select End of Line Sequence")), activeItem: EOLOptions[selectedIndex] });
+        const EOLOptions = [{
+            label: nlsEOLLF,
+            eol: EndOfLineSequence.LF
+        }, {
+            label: nlsEOLCRLF,
+            eol: EndOfLineSequence.CRLF
+        }];
+        const selectedIndex = (textModel?.getEOL() === "\n") ? 0 : 1;
+        const eol = await quickInputService.pick(EOLOptions, {
+            placeHolder: ( localize(3497, "Select End of Line Sequence")),
+            activeItem: EOLOptions[selectedIndex]
+        });
         if (eol) {
             const activeCodeEditor = getCodeEditor(editorService.activeTextEditorControl);
             if (activeCodeEditor?.hasModel() && !editorService.activeEditor?.isReadonly()) {
@@ -1152,8 +1297,8 @@ class ChangeEOLAction extends Action2 {
 class ChangeEncodingAction extends Action2 {
     constructor() {
         super({
-            id: 'workbench.action.editor.changeEncoding',
-            title: ( localize2(3494, 'Change File Encoding')),
+            id: "workbench.action.editor.changeEncoding",
+            title: ( localize2(3498, "Change File Encoding")),
             f1: true
         });
     }
@@ -1166,27 +1311,37 @@ class ChangeEncodingAction extends Action2 {
         const dialogService = accessor.get(IDialogService);
         const activeTextEditorControl = getCodeEditor(editorService.activeTextEditorControl);
         if (!activeTextEditorControl) {
-            await quickInputService.pick([{ label: ( localize(3450, "No text editor active at this time")) }]);
+            await quickInputService.pick([{
+                label: ( localize(3454, "No text editor active at this time"))
+            }]);
             return;
         }
         const activeEditorPane = editorService.activeEditorPane;
         if (!activeEditorPane) {
-            await quickInputService.pick([{ label: ( localize(3450, "No text editor active at this time")) }]);
+            await quickInputService.pick([{
+                label: ( localize(3454, "No text editor active at this time"))
+            }]);
             return;
         }
         const encodingSupport = toEditorWithEncodingSupport(activeEditorPane.input);
         if (!encodingSupport) {
-            await quickInputService.pick([{ label: ( localize(3495, "No file active at this time")) }]);
+            await quickInputService.pick([{
+                label: ( localize(3499, "No file active at this time"))
+            }]);
             return;
         }
-        const saveWithEncodingPick = { label: ( localize(3496, "Save with Encoding")) };
-        const reopenWithEncodingPick = { label: ( localize(3497, "Reopen with Encoding")) };
+        const saveWithEncodingPick = {
+            label: ( localize(3500, "Save with Encoding"))
+        };
+        const reopenWithEncodingPick = {
+            label: ( localize(3501, "Reopen with Encoding"))
+        };
         if (!Language.isDefaultVariant()) {
-            const saveWithEncodingAlias = 'Save with Encoding';
+            const saveWithEncodingAlias = "Save with Encoding";
             if (saveWithEncodingAlias !== saveWithEncodingPick.label) {
                 saveWithEncodingPick.detail = saveWithEncodingAlias;
             }
-            const reopenWithEncodingAlias = 'Reopen with Encoding';
+            const reopenWithEncodingAlias = "Reopen with Encoding";
             if (reopenWithEncodingAlias !== reopenWithEncodingPick.label) {
                 reopenWithEncodingPick.detail = reopenWithEncodingAlias;
             }
@@ -1194,18 +1349,21 @@ class ChangeEncodingAction extends Action2 {
         let action;
         if (encodingSupport instanceof UntitledTextEditorInput) {
             action = saveWithEncodingPick;
-        }
-        else if (activeEditorPane.input.isReadonly()) {
+        } else if (activeEditorPane.input.isReadonly()) {
             action = reopenWithEncodingPick;
-        }
-        else {
-            action = await quickInputService.pick([reopenWithEncodingPick, saveWithEncodingPick], { placeHolder: ( localize(3454, "Select Action")), matchOnDetail: true });
+        } else {
+            action = await quickInputService.pick([reopenWithEncodingPick, saveWithEncodingPick], {
+                placeHolder: ( localize(3458, "Select Action")),
+                matchOnDetail: true
+            });
         }
         if (!action) {
             return;
         }
         await timeout(50);
-        const resource = EditorResourceAccessor.getOriginalUri(activeEditorPane.input, { supportSideBySide: SideBySideEditor.PRIMARY });
+        const resource = EditorResourceAccessor.getOriginalUri(activeEditorPane.input, {
+            supportSideBySide: SideBySideEditor.PRIMARY
+        });
         if (!resource || (!fileService.hasProvider(resource) && resource.scheme !== Schemas.untitled)) {
             return;
         }
@@ -1213,47 +1371,52 @@ class ChangeEncodingAction extends Action2 {
         if (fileService.hasProvider(resource)) {
             const content = await textFileService.readStream(resource, {
                 autoGuessEncoding: true,
-                candidateGuessEncodings: textResourceConfigurationService.getValue(resource, 'files.candidateGuessEncodings')
+                candidateGuessEncodings: textResourceConfigurationService.getValue(resource, "files.candidateGuessEncodings")
             });
             guessedEncoding = content.encoding;
         }
         const isReopenWithEncoding = (action === reopenWithEncodingPick);
-        const configuredEncoding = textResourceConfigurationService.getValue(resource, 'files.encoding');
+        const configuredEncoding = textResourceConfigurationService.getValue(resource, "files.encoding");
         let directMatchIndex;
         let aliasMatchIndex;
-        const picks = ( ( Object.keys(SUPPORTED_ENCODINGS))
-            .sort((k1, k2) => {
+        const picks = ( ( Object.keys(SUPPORTED_ENCODINGS)).sort((k1, k2) => {
             if (k1 === configuredEncoding) {
                 return -1;
-            }
-            else if (k2 === configuredEncoding) {
+            } else if (k2 === configuredEncoding) {
                 return 1;
             }
             return SUPPORTED_ENCODINGS[k1].order - SUPPORTED_ENCODINGS[k2].order;
-        })
-            .filter(k => {
+        }).filter(k => {
             if (k === guessedEncoding && guessedEncoding !== configuredEncoding) {
                 return false;
             }
             return !isReopenWithEncoding || !SUPPORTED_ENCODINGS[k].encodeOnly;
-        })
-            .map((key, index) => {
+        }).map((key, index) => {
             if (key === encodingSupport.getEncoding()) {
                 directMatchIndex = index;
-            }
-            else if (SUPPORTED_ENCODINGS[key].alias === encodingSupport.getEncoding()) {
+            } else if (SUPPORTED_ENCODINGS[key].alias === encodingSupport.getEncoding()) {
                 aliasMatchIndex = index;
             }
-            return { id: key, label: SUPPORTED_ENCODINGS[key].labelLong, description: key };
+            return {
+                id: key,
+                label: SUPPORTED_ENCODINGS[key].labelLong,
+                description: key
+            };
         }));
         const items = picks.slice();
         if (guessedEncoding && configuredEncoding !== guessedEncoding && SUPPORTED_ENCODINGS[guessedEncoding]) {
-            picks.unshift({ type: 'separator' });
-            picks.unshift({ id: guessedEncoding, label: SUPPORTED_ENCODINGS[guessedEncoding].labelLong, description: ( localize(3498, "Guessed from content")) });
+            picks.unshift({
+                type: "separator"
+            });
+            picks.unshift({
+                id: guessedEncoding,
+                label: SUPPORTED_ENCODINGS[guessedEncoding].labelLong,
+                description: ( localize(3502, "Guessed from content"))
+            });
         }
         const encoding = await quickInputService.pick(picks, {
-            placeHolder: isReopenWithEncoding ? ( localize(3499, "Select File Encoding to Reopen File")) : ( localize(3500, "Select File Encoding to Save with")),
-            activeItem: items[typeof directMatchIndex === 'number' ? directMatchIndex : typeof aliasMatchIndex === 'number' ? aliasMatchIndex : -1]
+            placeHolder: isReopenWithEncoding ? ( localize(3503, "Select File Encoding to Reopen File")) : ( localize(3504, "Select File Encoding to Save with")),
+            activeItem: items[typeof directMatchIndex === "number" ? directMatchIndex : typeof aliasMatchIndex === "number" ? aliasMatchIndex : -1]
         });
         if (!encoding) {
             return;
@@ -1262,25 +1425,30 @@ class ChangeEncodingAction extends Action2 {
             return;
         }
         const activeEncodingSupport = toEditorWithEncodingSupport(editorService.activeEditorPane.input);
-        if (typeof encoding.id !== 'undefined' && activeEncodingSupport) {
+        if (typeof encoding.id !== "undefined" && activeEncodingSupport) {
             if (isReopenWithEncoding && editorService.activeEditorPane.input.isDirty()) {
-                const { confirmed } = await dialogService.confirm({
+                const {
+                    confirmed
+                } = await dialogService.confirm({
                     message: ( localize(
-                        3501,
+                        3505,
                         "Do you want to revert the active text editor and reopen with a different encoding?"
                     )),
-                    detail: ( localize(3502, "This will discard any unsaved changes.")),
-                    primaryButton: ( localize(3503, "Discard Changes and Reopen"))
+                    detail: ( localize(3506, "This will discard any unsaved changes.")),
+                    primaryButton: ( localize(3507, "Discard Changes and Reopen"))
                 });
                 if (!confirmed) {
                     return;
                 }
                 await editorService.activeEditorPane.input.revert(editorService.activeEditorPane.group.id);
             }
-            await activeEncodingSupport.setEncoding(encoding.id, isReopenWithEncoding ? EncodingMode.Decode : EncodingMode.Encode);
+            await activeEncodingSupport.setEncoding(
+                encoding.id,
+                isReopenWithEncoding ? EncodingMode.Decode : EncodingMode.Encode
+            );
         }
         activeTextEditorControl.focus();
     }
 }
 
-export { ChangeEOLAction, ChangeEncodingAction, ChangeLanguageAction, EditorStatusContribution, ShowLanguageExtensionsAction };
+export { ChangeEOLAction, ChangeEncodingAction, ChangeLanguageAction, EditorStatusContribution };