@codingame/monaco-vscode-api 1.78.5 → 1.78.6

package/dist/vscode/vs/workbench/browser/parts/auxiliarybar/auxiliaryBarActions.js

@@ -1,146 +0,0 @@
-import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { registerAction2, MenuRegistry, MenuId, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
-import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
-import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
-import { AuxiliaryBarVisibleContext } from '../../../common/contextkeys.js';
-import { ViewContainerLocationToString } from '../../../common/views.js';
-import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
-import { IPaneCompositePartService } from '../../../services/panecomposite/browser/panecomposite.js';
-var _a;
-const auxiliaryBarRightIcon = ( registerIcon(
-    'auxiliarybar-right-layout-icon',
-    Codicon.layoutSidebarRight,
-    ( localize(
-        'toggleAuxiliaryIconRight',
-        'Icon to toggle the auxiliary bar off in its right position.'
-    ))
-));
-const auxiliaryBarRightOffIcon = ( registerIcon(
-    'auxiliarybar-right-off-layout-icon',
-    Codicon.layoutSidebarRightOff,
-    ( localize(
-        'toggleAuxiliaryIconRightOn',
-        'Icon to toggle the auxiliary bar on in its right position.'
-    ))
-));
-const auxiliaryBarLeftIcon = ( registerIcon('auxiliarybar-left-layout-icon', Codicon.layoutSidebarLeft, ( localize(
-    'toggleAuxiliaryIconLeft',
-    'Icon to toggle the auxiliary bar in its left position.'
-))));
-const auxiliaryBarLeftOffIcon = ( registerIcon(
-    'auxiliarybar-left-off-layout-icon',
-    Codicon.layoutSidebarLeftOff,
-    ( localize(
-        'toggleAuxiliaryIconLeftOn',
-        'Icon to toggle the auxiliary bar on in its left position.'
-    ))
-));
-class ToggleAuxiliaryBarAction extends Action2 {
-    constructor() {
-        super({
-            id: ToggleAuxiliaryBarAction.ID,
-            title: { value: ToggleAuxiliaryBarAction.LABEL, original: 'Toggle Secondary Side Bar Visibility' },
-            toggled: {
-                condition: AuxiliaryBarVisibleContext,
-                title: ( localize('secondary sidebar', "Secondary Side Bar")),
-                mnemonicTitle: ( localize(
-                    { key: 'secondary sidebar mnemonic', comment: ['&& denotes a mnemonic'] },
-                    "Secondary Si&&de Bar"
-                )),
-            },
-            category: Categories.View,
-            f1: true,
-            keybinding: {
-                weight: 200 ,
-                primary: 2048  | 512  | 32
-            },
-            menu: [
-                {
-                    id: MenuId.LayoutControlMenuSubmenu,
-                    group: '0_workbench_layout',
-                    order: 1
-                },
-                {
-                    id: MenuId.MenubarAppearanceMenu,
-                    group: '2_workbench_layout',
-                    order: 2
-                }
-            ]
-        });
-    }
-    async run(accessor) {
-        const layoutService = accessor.get(IWorkbenchLayoutService);
-        layoutService.setPartHidden(layoutService.isVisible("workbench.parts.auxiliarybar" ), "workbench.parts.auxiliarybar" );
-    }
-}
-ToggleAuxiliaryBarAction.ID = 'workbench.action.toggleAuxiliaryBar';
-ToggleAuxiliaryBarAction.LABEL = ( localize('toggleAuxiliaryBar', "Toggle Secondary Side Bar Visibility"));
-registerAction2(ToggleAuxiliaryBarAction);
-registerAction2((_a = class FocusAuxiliaryBarAction extends Action2 {
-        constructor() {
-            super({
-                id: FocusAuxiliaryBarAction.ID,
-                title: { value: FocusAuxiliaryBarAction.LABEL, original: 'Focus into Secondary Side Bar' },
-                category: Categories.View,
-                f1: true,
-            });
-        }
-        async run(accessor) {
-            const paneCompositeService = accessor.get(IPaneCompositePartService);
-            const layoutService = accessor.get(IWorkbenchLayoutService);
-            if (!layoutService.isVisible("workbench.parts.auxiliarybar" )) {
-                layoutService.setPartHidden(false, "workbench.parts.auxiliarybar" );
-            }
-            const composite = paneCompositeService.getActivePaneComposite(2 );
-            composite?.focus();
-        }
-    },
-    _a.ID = 'workbench.action.focusAuxiliaryBar',
-    _a.LABEL = ( localize('focusAuxiliaryBar', "Focus into Secondary Side Bar")),
-    _a));
-MenuRegistry.appendMenuItems([
-    {
-        id: MenuId.LayoutControlMenu,
-        item: {
-            group: '0_workbench_toggles',
-            command: {
-                id: ToggleAuxiliaryBarAction.ID,
-                title: ( localize('toggleSecondarySideBar', "Toggle Secondary Side Bar")),
-                toggled: { condition: AuxiliaryBarVisibleContext, icon: auxiliaryBarLeftIcon },
-                icon: auxiliaryBarLeftOffIcon,
-            },
-            when: ( ContextKeyExpr.and(( ContextKeyExpr.or(( ContextKeyExpr.equals('config.workbench.layoutControl.type', 'toggles')), ( ContextKeyExpr.equals('config.workbench.layoutControl.type', 'both')))), ( ContextKeyExpr.equals('config.workbench.sideBar.location', 'right')))),
-            order: 0
-        }
-    }, {
-        id: MenuId.LayoutControlMenu,
-        item: {
-            group: '0_workbench_toggles',
-            command: {
-                id: ToggleAuxiliaryBarAction.ID,
-                title: ( localize('toggleSecondarySideBar', "Toggle Secondary Side Bar")),
-                toggled: { condition: AuxiliaryBarVisibleContext, icon: auxiliaryBarRightIcon },
-                icon: auxiliaryBarRightOffIcon,
-            },
-            when: ( ContextKeyExpr.and(( ContextKeyExpr.or(( ContextKeyExpr.equals('config.workbench.layoutControl.type', 'toggles')), ( ContextKeyExpr.equals('config.workbench.layoutControl.type', 'both')))), ( ContextKeyExpr.equals('config.workbench.sideBar.location', 'left')))),
-            order: 2
-        }
-    }, {
-        id: MenuId.ViewTitleContext,
-        item: {
-            group: '3_workbench_layout_move',
-            command: {
-                id: ToggleAuxiliaryBarAction.ID,
-                title: { value: ( localize('hideAuxiliaryBar', "Hide Secondary Side Bar")), original: 'Hide Secondary Side Bar' },
-            },
-            when: ( ContextKeyExpr.and(AuxiliaryBarVisibleContext, ( ContextKeyExpr.equals(
-                'viewLocation',
-                ViewContainerLocationToString(2 )
-            )))),
-            order: 2
-        }
-    }
-]);
-export { ToggleAuxiliaryBarAction };

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

@@ -1,460 +0,0 @@
-import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import "../../../../../../assets/editorstatus.css";
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { extname, basename } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { withNullAsUndefined, withUndefinedAsNull, areFunctions } from 'monaco-editor/esm/vs/base/common/types.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
-import { Language } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { UntitledTextEditorInput } from '../../../services/untitled/common/untitledTextEditorInput.js';
-import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
-import { IEditorService } from '../../../services/editor/common/editorService.js';
-import { FILES_ASSOCIATIONS_CONFIG, IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
-import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { IExtensionGalleryService } from '../../../../platform/extensionManagement/common/extensionManagement.js';
-import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
-import { SUPPORTED_ENCODINGS } from '../../../services/textfile/common/encoding.js';
-import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
-import { getCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { IPreferencesService } from '../../../services/preferences/common/preferences.js';
-import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
-import { getIconClassesForLanguageId } from 'monaco-editor/esm/vs/editor/common/services/getIconClasses.js';
-import { timeout, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { SideBySideEditorInput } from '../../../common/editor/sideBySideEditorInput.js';
-import { ILanguageDetectionService, AutomaticLanguageDetectionLikelyWrongId } from '../../../services/languageDetection/common/languageDetectionWorkerService.js';
-import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
-import { KeyChord } from 'monaco-editor/esm/vs/base/common/keyCodes.js';
-class SideBySideEditorEncodingSupport {
-    constructor(primary, secondary) {
-        this.primary = primary;
-        this.secondary = secondary;
-    }
-    getEncoding() {
-        return this.primary.getEncoding();
-    }
-    async setEncoding(encoding, mode) {
-        await Promises.settled(( [this.primary, this.secondary].map(editor => editor.setEncoding(encoding, mode))));
-    }
-}
-class SideBySideEditorLanguageSupport {
-    constructor(primary, secondary) {
-        this.primary = primary;
-        this.secondary = secondary;
-    }
-    setLanguageId(languageId, source) {
-        [this.primary, this.secondary].forEach(editor => editor.setLanguageId(languageId, source));
-    }
-}
-function toEditorWithEncodingSupport(input) {
-    if (input instanceof UntitledTextEditorInput) {
-        return input;
-    }
-    if (input instanceof SideBySideEditorInput) {
-        const primaryEncodingSupport = toEditorWithEncodingSupport(input.primary);
-        const secondaryEncodingSupport = toEditorWithEncodingSupport(input.secondary);
-        if (primaryEncodingSupport && secondaryEncodingSupport) {
-            return ( new SideBySideEditorEncodingSupport(primaryEncodingSupport, secondaryEncodingSupport));
-        }
-        return primaryEncodingSupport;
-    }
-    const encodingSupport = input;
-    if (areFunctions(encodingSupport.setEncoding, encodingSupport.getEncoding)) {
-        return encodingSupport;
-    }
-    return null;
-}
-function toEditorWithLanguageSupport(input) {
-    if (input instanceof UntitledTextEditorInput) {
-        return input;
-    }
-    if (input instanceof SideBySideEditorInput) {
-        const primaryLanguageSupport = toEditorWithLanguageSupport(input.primary);
-        const secondaryLanguageSupport = toEditorWithLanguageSupport(input.secondary);
-        if (primaryLanguageSupport && secondaryLanguageSupport) {
-            return ( new SideBySideEditorLanguageSupport(primaryLanguageSupport, secondaryLanguageSupport));
-        }
-        return primaryLanguageSupport;
-    }
-    const languageSupport = input;
-    if (typeof languageSupport.setLanguageId === 'function') {
-        return languageSupport;
-    }
-    return null;
-}
-const nlsEOLLF = ( localize('endOfLineLineFeed', "LF"));
-const nlsEOLCRLF = ( localize('endOfLineCarriageReturnLineFeed', "CRLF"));
-let ShowLanguageExtensionsAction = class ShowLanguageExtensionsAction extends Action {
-    constructor(fileExtension, commandService, galleryService) {
-        super(ShowLanguageExtensionsAction.ID, ( localize(
-            'showLanguageExtensions',
-            "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.ID = 'workbench.action.showLanguageExtensions';
-ShowLanguageExtensionsAction = ( __decorate([
-    ( __param(1, ICommandService)),
-    ( __param(2, IExtensionGalleryService))
-], ShowLanguageExtensionsAction));
-class ChangeLanguageAction extends Action2 {
-    constructor() {
-        super({
-            id: ChangeLanguageAction.ID,
-            title: { value: ( localize('changeMode', "Change Language Mode")), original: 'Change Language Mode' },
-            f1: true,
-            keybinding: {
-                weight: 200 ,
-                primary: KeyChord(2048  | 41 , 43 )
-            },
-            precondition: ContextKeyExpr.not('notebookEditorFocused')
-        });
-    }
-    async run(accessor) {
-        const quickInputService = accessor.get(IQuickInputService);
-        const editorService = accessor.get(IEditorService);
-        const languageService = accessor.get(ILanguageService);
-        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 activeTextEditorControl = getCodeEditor(editorService.activeTextEditorControl);
-        if (!activeTextEditorControl) {
-            await quickInputService.pick([{ label: ( localize('noEditor', "No text editor active at this time")) }]);
-            return;
-        }
-        const textModel = activeTextEditorControl.getModel();
-        const resource = EditorResourceAccessor.getOriginalUri(editorService.activeEditor, { supportSideBySide: SideBySideEditor.PRIMARY });
-        let currentLanguageName;
-        let currentLanguageId;
-        if (textModel) {
-            currentLanguageId = textModel.getLanguageId();
-            currentLanguageName = withNullAsUndefined(languageService.getLanguageName(currentLanguageId));
-        }
-        let hasLanguageSupport = !!resource;
-        if (resource?.scheme === Schemas.untitled && !textFileService.untitled.get(resource)?.hasAssociatedFilePath) {
-            hasLanguageSupport = false;
-        }
-        const languages = languageService.getSortedRegisteredLanguageNames();
-        const picks = ( languages
-            .map(({ languageName, languageId }) => {
-            const extensions = languageService.getExtensions(languageId).join(' ');
-            let description;
-            if (currentLanguageName === languageName) {
-                description = ( localize('languageDescription', "({0}) - Configured Language", languageId));
-            }
-            else {
-                description = ( localize('languageDescriptionConfigured', "({0})", languageId));
-            }
-            return {
-                label: languageName,
-                meta: extensions,
-                iconClasses: getIconClassesForLanguageId(languageId),
-                description
-            };
-        }));
-        picks.unshift({ type: 'separator', label: ( localize('languagesPicks', "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) {
-                picks.unshift(galleryAction);
-            }
-            configureLanguageSettings = { label: ( localize(
-                'configureModeSettings',
-                "Configure '{0}' language based settings...",
-                currentLanguageName
-            )) };
-            picks.unshift(configureLanguageSettings);
-            configureLanguageAssociations = { label: ( localize('configureAssociationsExt', "Configure File Association for '{0}'...", ext)) };
-            picks.unshift(configureLanguageAssociations);
-        }
-        const autoDetectLanguage = {
-            label: ( localize('autoDetect', "Auto Detect"))
-        };
-        picks.unshift(autoDetectLanguage);
-        const pick = await quickInputService.pick(picks, { placeHolder: ( localize('pickLanguage', "Select Language Mode")), matchOnDescription: true });
-        if (!pick) {
-            return;
-        }
-        if (pick === galleryAction) {
-            galleryAction.run();
-            return;
-        }
-        if (pick === configureLanguageAssociations) {
-            if (resource) {
-                this.configureFileAssociation(resource, languageService, quickInputService, configurationService);
-            }
-            return;
-        }
-        if (pick === configureLanguageSettings) {
-            preferencesService.openUserSettings({ jsonEditor: true, revealSetting: { key: `[${withUndefinedAsNull(currentLanguageId)}]`, edit: true } });
-            return;
-        }
-        const activeEditor = editorService.activeEditor;
-        if (activeEditor) {
-            const languageSupport = toEditorWithLanguageSupport(activeEditor);
-            if (languageSupport) {
-                let languageSelection;
-                let detectedLanguage;
-                if (pick === autoDetectLanguage) {
-                    if (textModel) {
-                        const resource = EditorResourceAccessor.getOriginalUri(activeEditor, { supportSideBySide: SideBySideEditor.PRIMARY });
-                        if (resource) {
-                            let languageId = withNullAsUndefined(languageService.guessLanguageIdByFilepathOrFirstLine(resource, textModel.getLineContent(1)));
-                            if (!languageId || languageId === 'unknown') {
-                                detectedLanguage = await languageDetectionService.detectLanguage(resource);
-                                languageId = detectedLanguage;
-                            }
-                            if (languageId) {
-                                languageSelection = languageService.createById(languageId);
-                            }
-                        }
-                    }
-                }
-                else {
-                    const languageId = languageService.getLanguageIdByLanguageName(pick.label);
-                    languageSelection = languageService.createById(languageId);
-                    if (resource) {
-                        languageDetectionService.detectLanguage(resource).then(detectedLanguageId => {
-                            const chosenLanguageId = languageService.getLanguageIdByLanguageName(pick.label) || 'unknown';
-                            if (detectedLanguageId === currentLanguageId && currentLanguageId !== chosenLanguageId) {
-                                const modelPreference = configurationService.getValue('workbench.editor.preferHistoryBasedLanguageDetection') ? 'history' : 'classic';
-                                telemetryService.publicLog2(AutomaticLanguageDetectionLikelyWrongId, {
-                                    currentLanguageId: currentLanguageName ?? 'unknown',
-                                    nextLanguageId: pick.label,
-                                    lineCount: textModel?.getLineCount() ?? -1,
-                                    modelPreference,
-                                });
-                            }
-                        });
-                    }
-                }
-                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', {
-                            to: languageSelection.languageId,
-                            from: currentLanguageId ?? 'none',
-                            modelPreference,
-                        });
-                    }
-                }
-            }
-            activeTextEditorControl.focus();
-        }
-    }
-    configureFileAssociation(resource, languageService, quickInputService, configurationService) {
-        const extension = extname(resource);
-        const base = basename(resource);
-        const currentAssociation = languageService.guessLanguageIdByFilepathOrFirstLine(URI.file(base));
-        const languages = languageService.getSortedRegisteredLanguageNames();
-        const picks = ( languages.map(({ languageName, languageId }) => {
-            return {
-                id: languageId,
-                label: languageName,
-                iconClasses: getIconClassesForLanguageId(languageId),
-                description: (languageId === currentAssociation) ? ( localize('currentAssociation', "Current Association")) : undefined
-            };
-        }));
-        setTimeout(async () => {
-            const language = await quickInputService.pick(picks, { placeHolder: ( localize(
-                'pickLanguageToConfigure',
-                "Select Language Mode to Associate with '{0}'",
-                extension || base
-            )) });
-            if (language) {
-                const fileAssociationsConfig = configurationService.inspect(FILES_ASSOCIATIONS_CONFIG);
-                let associationKey;
-                if (extension && base[0] !== '.') {
-                    associationKey = `*${extension}`;
-                }
-                else {
-                    associationKey = base;
-                }
-                let target = 2 ;
-                if (fileAssociationsConfig.workspaceValue && !!fileAssociationsConfig.workspaceValue[associationKey]) {
-                    target = 5 ;
-                }
-                const currentAssociations = deepClone(((target === 5) ) ? fileAssociationsConfig.workspaceValue : fileAssociationsConfig.userValue) || Object.create(null);
-                currentAssociations[associationKey] = language.id;
-                configurationService.updateValue(FILES_ASSOCIATIONS_CONFIG, currentAssociations, target);
-            }
-        }, 50 );
-    }
-}
-ChangeLanguageAction.ID = 'workbench.action.editor.changeLanguageMode';
-class ChangeEOLAction extends Action2 {
-    constructor() {
-        super({
-            id: 'workbench.action.editor.changeEOL',
-            title: { value: ( localize('changeEndOfLine', "Change End of Line Sequence")), original: 'Change End of Line Sequence' },
-            f1: true
-        });
-    }
-    async run(accessor) {
-        const editorService = accessor.get(IEditorService);
-        const quickInputService = accessor.get(IQuickInputService);
-        const activeTextEditorControl = getCodeEditor(editorService.activeTextEditorControl);
-        if (!activeTextEditorControl) {
-            await quickInputService.pick([{ label: ( localize('noEditor', "No text editor active at this time")) }]);
-            return;
-        }
-        if (editorService.activeEditor?.hasCapability(2 )) {
-            await quickInputService.pick([{ label: ( localize('noWritableCodeEditor', "The active code editor is read-only.")) }]);
-            return;
-        }
-        let textModel = activeTextEditorControl.getModel();
-        const EOLOptions = [
-            { label: nlsEOLLF, eol: 0  },
-            { label: nlsEOLCRLF, eol: 1  },
-        ];
-        const selectedIndex = (textModel?.getEOL() === '\n') ? 0 : 1;
-        const eol = await quickInputService.pick(EOLOptions, { placeHolder: ( localize('pickEndOfLine', "Select End of Line Sequence")), activeItem: EOLOptions[selectedIndex] });
-        if (eol) {
-            const activeCodeEditor = getCodeEditor(editorService.activeTextEditorControl);
-            if (activeCodeEditor?.hasModel() && !editorService.activeEditor?.hasCapability(2 )) {
-                textModel = activeCodeEditor.getModel();
-                textModel.pushStackElement();
-                textModel.pushEOL(eol.eol);
-                textModel.pushStackElement();
-            }
-        }
-        activeTextEditorControl.focus();
-    }
-}
-class ChangeEncodingAction extends Action2 {
-    constructor() {
-        super({
-            id: 'workbench.action.editor.changeEncoding',
-            title: { value: ( localize('changeEncoding', "Change File Encoding")), original: 'Change File Encoding' },
-            f1: true
-        });
-    }
-    async run(accessor) {
-        const editorService = accessor.get(IEditorService);
-        const quickInputService = accessor.get(IQuickInputService);
-        const fileService = accessor.get(IFileService);
-        const textFileService = accessor.get(ITextFileService);
-        const textResourceConfigurationService = accessor.get(ITextResourceConfigurationService);
-        const activeTextEditorControl = getCodeEditor(editorService.activeTextEditorControl);
-        if (!activeTextEditorControl) {
-            await quickInputService.pick([{ label: ( localize('noEditor', "No text editor active at this time")) }]);
-            return;
-        }
-        const activeEditorPane = editorService.activeEditorPane;
-        if (!activeEditorPane) {
-            await quickInputService.pick([{ label: ( localize('noEditor', "No text editor active at this time")) }]);
-            return;
-        }
-        const encodingSupport = toEditorWithEncodingSupport(activeEditorPane.input);
-        if (!encodingSupport) {
-            await quickInputService.pick([{ label: ( localize('noFileEditor', "No file active at this time")) }]);
-            return;
-        }
-        const saveWithEncodingPick = { label: ( localize('saveWithEncoding', "Save with Encoding")) };
-        const reopenWithEncodingPick = { label: ( localize('reopenWithEncoding', "Reopen with Encoding")) };
-        if (!Language.isDefaultVariant()) {
-            const saveWithEncodingAlias = 'Save with Encoding';
-            if (saveWithEncodingAlias !== saveWithEncodingPick.label) {
-                saveWithEncodingPick.detail = saveWithEncodingAlias;
-            }
-            const reopenWithEncodingAlias = 'Reopen with Encoding';
-            if (reopenWithEncodingAlias !== reopenWithEncodingPick.label) {
-                reopenWithEncodingPick.detail = reopenWithEncodingAlias;
-            }
-        }
-        let action;
-        if (encodingSupport instanceof UntitledTextEditorInput) {
-            action = saveWithEncodingPick;
-        }
-        else if (activeEditorPane.input.hasCapability(2 )) {
-            action = reopenWithEncodingPick;
-        }
-        else {
-            action = await quickInputService.pick([reopenWithEncodingPick, saveWithEncodingPick], { placeHolder: ( localize('pickAction', "Select Action")), matchOnDetail: true });
-        }
-        if (!action) {
-            return;
-        }
-        await timeout(50);
-        const resource = EditorResourceAccessor.getOriginalUri(activeEditorPane.input, { supportSideBySide: SideBySideEditor.PRIMARY });
-        if (!resource || (!fileService.hasProvider(resource) && resource.scheme !== Schemas.untitled)) {
-            return;
-        }
-        let guessedEncoding = undefined;
-        if (fileService.hasProvider(resource)) {
-            const content = await textFileService.readStream(resource, { autoGuessEncoding: true });
-            guessedEncoding = content.encoding;
-        }
-        const isReopenWithEncoding = (action === reopenWithEncodingPick);
-        const configuredEncoding = textResourceConfigurationService.getValue(withNullAsUndefined(resource), 'files.encoding');
-        let directMatchIndex;
-        let aliasMatchIndex;
-        const picks = ( ( Object.keys(SUPPORTED_ENCODINGS))
-            .sort((k1, k2) => {
-            if (k1 === configuredEncoding) {
-                return -1;
-            }
-            else if (k2 === configuredEncoding) {
-                return 1;
-            }
-            return SUPPORTED_ENCODINGS[k1].order - SUPPORTED_ENCODINGS[k2].order;
-        })
-            .filter(k => {
-            if (k === guessedEncoding && guessedEncoding !== configuredEncoding) {
-                return false;
-            }
-            return !isReopenWithEncoding || !SUPPORTED_ENCODINGS[k].encodeOnly;
-        })
-            .map((key, index) => {
-            if (key === encodingSupport.getEncoding()) {
-                directMatchIndex = index;
-            }
-            else if (SUPPORTED_ENCODINGS[key].alias === encodingSupport.getEncoding()) {
-                aliasMatchIndex = index;
-            }
-            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('guessedEncoding', "Guessed from content")) });
-        }
-        const encoding = await quickInputService.pick(picks, {
-            placeHolder: isReopenWithEncoding ? ( localize('pickEncodingForReopen', "Select File Encoding to Reopen File")) : ( localize('pickEncodingForSave', "Select File Encoding to Save with")),
-            activeItem: items[typeof directMatchIndex === 'number' ? directMatchIndex : typeof aliasMatchIndex === 'number' ? aliasMatchIndex : -1]
-        });
-        if (!encoding) {
-            return;
-        }
-        if (!editorService.activeEditorPane) {
-            return;
-        }
-        const activeEncodingSupport = toEditorWithEncodingSupport(editorService.activeEditorPane.input);
-        if (typeof encoding.id !== 'undefined' && activeEncodingSupport) {
-            await activeEncodingSupport.setEncoding(encoding.id, isReopenWithEncoding ? 1  : 0 );
-        }
-        activeTextEditorControl.focus();
-    }
-}
-export { ChangeEOLAction, ChangeEncodingAction, ChangeLanguageAction, ShowLanguageExtensionsAction };