@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/services/preferences/browser/preferencesService.js

@@ -0,0 +1,551 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { getErrorMessage } from '../../../../base/common/errors.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { parse } from '../../../../base/common/json.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { URI } from '../../../../base/common/uri.js';
+import { CoreEditingCommands } from '../../../../editor/browser/coreCommands.js';
+import { getCodeEditor } from '../../../../editor/browser/editorBrowser.js';
+import { IModelService } from '../../../../editor/common/services/model.js';
+import { ILanguageService } from '../../../../editor/common/languages/language.js';
+import { ITextModelService } from '../../../../editor/common/services/resolverService.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { Extensions, OVERRIDE_PROPERTY_REGEX, getDefaultValue } from '../../../../platform/configuration/common/configurationRegistry.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { ILabelService } from '../../../../platform/label/common/label.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+import { DEFAULT_EDITOR_ASSOCIATION } from '../../../common/editor.js';
+import { SideBySideEditorInput } from '../../../common/editor/sideBySideEditorInput.js';
+import { TextResourceEditorInput } from '../../../common/editor/textResourceEditorInput.js';
+import { IJSONEditingService } from '../../configuration/common/jsonEditing.js';
+import { IEditorGroupsService } from '../../editor/common/editorGroupsService.js';
+import { SIDE_GROUP, IEditorService } from '../../editor/common/editorService.js';
+import { KeybindingsEditorInput } from './keybindingsEditorInput.js';
+import { FOLDER_SETTINGS_PATH, validateSettingsEditorOptions, USE_SPLIT_JSON_SETTING, DEFAULT_SETTINGS_EDITOR_SETTING } from '../common/preferences.js';
+import { SettingsEditor2Input } from '../common/preferencesEditorInput.js';
+import { defaultKeybindingsContents, DefaultRawSettingsEditorModel, DefaultKeybindingsEditorModel, Settings2EditorModel, WorkspaceConfigurationEditorModel, SettingsEditorModel, DefaultSettingsEditorModel, DefaultSettings } from '../common/preferencesModels.js';
+import { IRemoteAgentService } from '../../remote/common/remoteAgentService.js';
+import { ITextEditorService } from '../../textfile/common/textEditorService.js';
+import { ITextFileService } from '../../textfile/common/textfiles.js';
+import { isObject } from '../../../../base/common/types.js';
+import { SuggestController } from '../../../../editor/contrib/suggest/browser/suggestController.js';
+import { IUserDataProfileService } from '../../userDataProfile/common/userDataProfile.js';
+import { IUserDataProfilesService } from '../../../../platform/userDataProfile/common/userDataProfile.js';
+const emptyEditableSettingsContent = '{\n}';
+let PreferencesService = class PreferencesService extends Disposable {
+    constructor(editorService, editorGroupService, textFileService, configurationService, notificationService, contextService, instantiationService, userDataProfileService, userDataProfilesService, textModelResolverService, keybindingService, modelService, jsonEditingService, languageService, labelService, remoteAgentService, textEditorService) {
+        super();
+        this.editorService = editorService;
+        this.editorGroupService = editorGroupService;
+        this.textFileService = textFileService;
+        this.configurationService = configurationService;
+        this.notificationService = notificationService;
+        this.contextService = contextService;
+        this.instantiationService = instantiationService;
+        this.userDataProfileService = userDataProfileService;
+        this.userDataProfilesService = userDataProfilesService;
+        this.textModelResolverService = textModelResolverService;
+        this.modelService = modelService;
+        this.jsonEditingService = jsonEditingService;
+        this.languageService = languageService;
+        this.labelService = labelService;
+        this.remoteAgentService = remoteAgentService;
+        this.textEditorService = textEditorService;
+        this._onDispose = this._register(( new Emitter()));
+        this.defaultKeybindingsResource = ( URI.from(
+            { scheme: Schemas.vscode, authority: 'defaultsettings', path: '/keybindings.json' }
+        ));
+        this.defaultSettingsRawResource = ( URI.from(
+            { scheme: Schemas.vscode, authority: 'defaultsettings', path: '/defaultSettings.json' }
+        ));
+        this._register(keybindingService.onDidUpdateKeybindings(() => {
+            const model = modelService.getModel(this.defaultKeybindingsResource);
+            if (!model) {
+                return;
+            }
+            modelService.updateModel(model, defaultKeybindingsContents(keybindingService));
+        }));
+    }
+    get userSettingsResource() {
+        return this.userDataProfileService.currentProfile.settingsResource;
+    }
+    get workspaceSettingsResource() {
+        if (this.contextService.getWorkbenchState() === 1 ) {
+            return null;
+        }
+        const workspace = this.contextService.getWorkspace();
+        return workspace.configuration || workspace.folders[0].toResource(FOLDER_SETTINGS_PATH);
+    }
+    createSettingsEditor2Input() {
+        return ( new SettingsEditor2Input(this));
+    }
+    getFolderSettingsResource(resource) {
+        const folder = this.contextService.getWorkspaceFolder(resource);
+        return folder ? folder.toResource(FOLDER_SETTINGS_PATH) : null;
+    }
+    resolveModel(uri) {
+        if (this.isDefaultSettingsResource(uri)) {
+            const target = this.getConfigurationTargetFromDefaultSettingsResource(uri);
+            const languageSelection = this.languageService.createById('jsonc');
+            const model = this._register(this.modelService.createModel('', languageSelection, uri));
+            let defaultSettings;
+            this.configurationService.onDidChangeConfiguration(e => {
+                if (e.source === 7 ) {
+                    const model = this.modelService.getModel(uri);
+                    if (!model) {
+                        return;
+                    }
+                    defaultSettings = this.getDefaultSettings(target);
+                    this.modelService.updateModel(model, defaultSettings.getContentWithoutMostCommonlyUsed(true));
+                    defaultSettings._onDidChange.fire();
+                }
+            });
+            if (!defaultSettings) {
+                defaultSettings = this.getDefaultSettings(target);
+                this.modelService.updateModel(model, defaultSettings.getContentWithoutMostCommonlyUsed(true));
+            }
+            return model;
+        }
+        if (( this.defaultSettingsRawResource.toString()) === ( uri.toString())) {
+            const defaultRawSettingsEditorModel = this.instantiationService.createInstance(DefaultRawSettingsEditorModel, this.getDefaultSettings(3 ));
+            const languageSelection = this.languageService.createById('jsonc');
+            const model = this._register(this.modelService.createModel(defaultRawSettingsEditorModel.content, languageSelection, uri));
+            return model;
+        }
+        if (( this.defaultKeybindingsResource.toString()) === ( uri.toString())) {
+            const defaultKeybindingsEditorModel = this.instantiationService.createInstance(DefaultKeybindingsEditorModel, uri);
+            const languageSelection = this.languageService.createById('jsonc');
+            const model = this._register(this.modelService.createModel(defaultKeybindingsEditorModel.content, languageSelection, uri));
+            return model;
+        }
+        return null;
+    }
+    async createPreferencesEditorModel(uri) {
+        if (this.isDefaultSettingsResource(uri)) {
+            return this.createDefaultSettingsEditorModel(uri);
+        }
+        if (( this.userSettingsResource.toString()) === ( uri.toString()) || ( this.userDataProfilesService.defaultProfile.settingsResource.toString()) === ( uri.toString())) {
+            return this.createEditableSettingsEditorModel(3 , uri);
+        }
+        const workspaceSettingsUri = await this.getEditableSettingsURI(5 );
+        if (workspaceSettingsUri && ( workspaceSettingsUri.toString()) === ( uri.toString())) {
+            return this.createEditableSettingsEditorModel(5 , workspaceSettingsUri);
+        }
+        if (this.contextService.getWorkbenchState() === 3 ) {
+            const settingsUri = await this.getEditableSettingsURI(6 , uri);
+            if (settingsUri && ( settingsUri.toString()) === ( uri.toString())) {
+                return this.createEditableSettingsEditorModel(6 , uri);
+            }
+        }
+        const remoteEnvironment = await this.remoteAgentService.getEnvironment();
+        const remoteSettingsUri = remoteEnvironment ? remoteEnvironment.settingsPath : null;
+        if (remoteSettingsUri && ( remoteSettingsUri.toString()) === ( uri.toString())) {
+            return this.createEditableSettingsEditorModel(4 , uri);
+        }
+        return null;
+    }
+    openRawDefaultSettings() {
+        return this.editorService.openEditor({ resource: this.defaultSettingsRawResource });
+    }
+    openRawUserSettings() {
+        return this.editorService.openEditor({ resource: this.userSettingsResource });
+    }
+    shouldOpenJsonByDefault() {
+        return this.configurationService.getValue('workbench.settings.editor') === 'json';
+    }
+    openSettings(options = {}) {
+        options = {
+            ...options,
+            target: 3 ,
+        };
+        if (options.query) {
+            options.jsonEditor = false;
+        }
+        return this.open(this.userSettingsResource, options);
+    }
+    openLanguageSpecificSettings(languageId, options = {}) {
+        if (this.shouldOpenJsonByDefault()) {
+            options.query = undefined;
+            options.revealSetting = { key: `[${languageId}]`, edit: true };
+        }
+        else {
+            options.query = `@lang:${languageId}${options.query ? ` ${options.query}` : ''}`;
+        }
+        options.target = options.target ?? 3 ;
+        return this.open(this.userSettingsResource, options);
+    }
+    open(settingsResource, options) {
+        options = {
+            ...options,
+            jsonEditor: options.jsonEditor ?? this.shouldOpenJsonByDefault()
+        };
+        return options.jsonEditor ?
+            this.openSettingsJson(settingsResource, options) :
+            this.openSettings2(options);
+    }
+    async openSettings2(options) {
+        const input = this.createSettingsEditor2Input();
+        options = {
+            ...options,
+            focusSearch: true
+        };
+        await this.editorService.openEditor(input, validateSettingsEditorOptions(options), options.openToSide ? SIDE_GROUP : undefined);
+        return this.editorGroupService.activeGroup.activeEditorPane;
+    }
+    openApplicationSettings(options = {}) {
+        options = {
+            ...options,
+            target: 3 ,
+        };
+        return this.open(this.userDataProfilesService.defaultProfile.settingsResource, options);
+    }
+    openUserSettings(options = {}) {
+        options = {
+            ...options,
+            target: 3 ,
+        };
+        return this.open(this.userSettingsResource, options);
+    }
+    async openRemoteSettings(options = {}) {
+        const environment = await this.remoteAgentService.getEnvironment();
+        if (environment) {
+            options = {
+                ...options,
+                target: 4 ,
+            };
+            this.open(environment.settingsPath, options);
+        }
+        return undefined;
+    }
+    openWorkspaceSettings(options = {}) {
+        if (!this.workspaceSettingsResource) {
+            this.notificationService.info(( localizeWithPath(
+                'vs/workbench/services/preferences/browser/preferencesService',
+                'openFolderFirst',
+                "Open a folder or workspace first to create workspace or folder settings."
+            )));
+            return Promise.reject(null);
+        }
+        options = {
+            ...options,
+            target: 5
+        };
+        return this.open(this.workspaceSettingsResource, options);
+    }
+    async openFolderSettings(options = {}) {
+        options = {
+            ...options,
+            target: 6
+        };
+        if (!options.folderUri) {
+            throw new Error(`Missing folder URI`);
+        }
+        const folderSettingsUri = await this.getEditableSettingsURI(6 , options.folderUri);
+        if (!folderSettingsUri) {
+            throw new Error(`Invalid folder URI - ${options.folderUri.toString()}`);
+        }
+        return this.open(folderSettingsUri, options);
+    }
+    async openGlobalKeybindingSettings(textual, options) {
+        options = { pinned: true, revealIfOpened: true, ...options };
+        if (textual) {
+            const emptyContents = '// ' + ( localizeWithPath(
+                'vs/workbench/services/preferences/browser/preferencesService',
+                'emptyKeybindingsHeader',
+                "Place your key bindings in this file to override the defaults"
+            )) + '\n[\n]';
+            const editableKeybindings = this.userDataProfileService.currentProfile.keybindingsResource;
+            const openDefaultKeybindings = !!this.configurationService.getValue('workbench.settings.openDefaultKeybindings');
+            await this.createIfNotExists(editableKeybindings, emptyContents);
+            if (openDefaultKeybindings) {
+                const activeEditorGroup = this.editorGroupService.activeGroup;
+                const sideEditorGroup = this.editorGroupService.addGroup(activeEditorGroup.id, 3 );
+                await Promise.all([
+                    this.editorService.openEditor({ resource: this.defaultKeybindingsResource, options: { pinned: true, preserveFocus: true, revealIfOpened: true, override: DEFAULT_EDITOR_ASSOCIATION.id }, label: ( localizeWithPath(
+                        'vs/workbench/services/preferences/browser/preferencesService',
+                        'defaultKeybindings',
+                        "Default Keybindings"
+                    )), description: '' }),
+                    this.editorService.openEditor({ resource: editableKeybindings, options }, sideEditorGroup.id)
+                ]);
+            }
+            else {
+                await this.editorService.openEditor({ resource: editableKeybindings, options });
+            }
+        }
+        else {
+            const editor = (await this.editorService.openEditor(this.instantiationService.createInstance(KeybindingsEditorInput), { ...options }));
+            if (options.query) {
+                editor.search(options.query);
+            }
+        }
+    }
+    openDefaultKeybindingsFile() {
+        return this.editorService.openEditor({ resource: this.defaultKeybindingsResource, label: ( localizeWithPath(
+            'vs/workbench/services/preferences/browser/preferencesService',
+            'defaultKeybindings',
+            "Default Keybindings"
+        )) });
+    }
+    async openSettingsJson(resource, options) {
+        const group = options?.openToSide ? SIDE_GROUP : undefined;
+        const editor = await this.doOpenSettingsJson(resource, options, group);
+        if (editor && options?.revealSetting) {
+            await this.revealSetting(options.revealSetting.key, !!options.revealSetting.edit, editor, resource);
+        }
+        return editor;
+    }
+    async doOpenSettingsJson(resource, options, group) {
+        const openSplitJSON = !!this.configurationService.getValue(USE_SPLIT_JSON_SETTING);
+        const openDefaultSettings = !!this.configurationService.getValue(DEFAULT_SETTINGS_EDITOR_SETTING);
+        if (openSplitJSON || openDefaultSettings) {
+            return this.doOpenSplitJSON(resource, options, group);
+        }
+        const configurationTarget = options?.target ?? 2 ;
+        const editableSettingsEditorInput = await this.getOrCreateEditableSettingsEditorInput(configurationTarget, resource);
+        options = { ...options, pinned: true };
+        return await this.editorService.openEditor(editableSettingsEditorInput, validateSettingsEditorOptions(options), group);
+    }
+    async doOpenSplitJSON(resource, options = {}, group) {
+        const configurationTarget = options.target ?? 2 ;
+        await this.createSettingsIfNotExists(configurationTarget, resource);
+        const preferencesEditorInput = this.createSplitJsonEditorInput(configurationTarget, resource);
+        options = { ...options, pinned: true };
+        return this.editorService.openEditor(preferencesEditorInput, validateSettingsEditorOptions(options), group);
+    }
+    createSplitJsonEditorInput(configurationTarget, resource) {
+        const editableSettingsEditorInput = this.textEditorService.createTextEditor({ resource });
+        const defaultPreferencesEditorInput = this.instantiationService.createInstance(TextResourceEditorInput, this.getDefaultSettingsResource(configurationTarget), undefined, undefined, undefined, undefined);
+        return this.instantiationService.createInstance(SideBySideEditorInput, editableSettingsEditorInput.getName(), undefined, defaultPreferencesEditorInput, editableSettingsEditorInput);
+    }
+    createSettings2EditorModel() {
+        return this.instantiationService.createInstance(Settings2EditorModel, this.getDefaultSettings(3 ));
+    }
+    getConfigurationTargetFromDefaultSettingsResource(uri) {
+        return this.isDefaultWorkspaceSettingsResource(uri) ?
+            5  :
+            this.isDefaultFolderSettingsResource(uri) ?
+                6  :
+                3 ;
+    }
+    isDefaultSettingsResource(uri) {
+        return this.isDefaultUserSettingsResource(uri) || this.isDefaultWorkspaceSettingsResource(uri) || this.isDefaultFolderSettingsResource(uri);
+    }
+    isDefaultUserSettingsResource(uri) {
+        return uri.authority === 'defaultsettings' && uri.scheme === Schemas.vscode && !!uri.path.match(/\/(\d+\/)?settings\.json$/);
+    }
+    isDefaultWorkspaceSettingsResource(uri) {
+        return uri.authority === 'defaultsettings' && uri.scheme === Schemas.vscode && !!uri.path.match(/\/(\d+\/)?workspaceSettings\.json$/);
+    }
+    isDefaultFolderSettingsResource(uri) {
+        return uri.authority === 'defaultsettings' && uri.scheme === Schemas.vscode && !!uri.path.match(/\/(\d+\/)?resourceSettings\.json$/);
+    }
+    getDefaultSettingsResource(configurationTarget) {
+        switch (configurationTarget) {
+            case 5 :
+                return ( URI.from(
+                    { scheme: Schemas.vscode, authority: 'defaultsettings', path: `/workspaceSettings.json` }
+                ));
+            case 6 :
+                return ( URI.from(
+                    { scheme: Schemas.vscode, authority: 'defaultsettings', path: `/resourceSettings.json` }
+                ));
+        }
+        return ( URI.from(
+            { scheme: Schemas.vscode, authority: 'defaultsettings', path: `/settings.json` }
+        ));
+    }
+    async getOrCreateEditableSettingsEditorInput(target, resource) {
+        await this.createSettingsIfNotExists(target, resource);
+        return this.textEditorService.createTextEditor({ resource });
+    }
+    async createEditableSettingsEditorModel(configurationTarget, settingsUri) {
+        const workspace = this.contextService.getWorkspace();
+        if (workspace.configuration && ( workspace.configuration.toString()) === ( settingsUri.toString())) {
+            const reference = await this.textModelResolverService.createModelReference(settingsUri);
+            return this.instantiationService.createInstance(WorkspaceConfigurationEditorModel, reference, configurationTarget);
+        }
+        const reference = await this.textModelResolverService.createModelReference(settingsUri);
+        return this.instantiationService.createInstance(SettingsEditorModel, reference, configurationTarget);
+    }
+    async createDefaultSettingsEditorModel(defaultSettingsUri) {
+        const reference = await this.textModelResolverService.createModelReference(defaultSettingsUri);
+        const target = this.getConfigurationTargetFromDefaultSettingsResource(defaultSettingsUri);
+        return this.instantiationService.createInstance(DefaultSettingsEditorModel, defaultSettingsUri, reference, this.getDefaultSettings(target));
+    }
+    getDefaultSettings(target) {
+        if (target === 5 ) {
+            this._defaultWorkspaceSettingsContentModel ??= this._register(( new DefaultSettings(this.getMostCommonlyUsedSettings(), target)));
+            return this._defaultWorkspaceSettingsContentModel;
+        }
+        if (target === 6 ) {
+            this._defaultFolderSettingsContentModel ??= this._register(( new DefaultSettings(this.getMostCommonlyUsedSettings(), target)));
+            return this._defaultFolderSettingsContentModel;
+        }
+        this._defaultUserSettingsContentModel ??= this._register(( new DefaultSettings(this.getMostCommonlyUsedSettings(), target)));
+        return this._defaultUserSettingsContentModel;
+    }
+    async getEditableSettingsURI(configurationTarget, resource) {
+        switch (configurationTarget) {
+            case 1 :
+                return this.userDataProfilesService.defaultProfile.settingsResource;
+            case 2 :
+            case 3 :
+                return this.userSettingsResource;
+            case 4 : {
+                const remoteEnvironment = await this.remoteAgentService.getEnvironment();
+                return remoteEnvironment ? remoteEnvironment.settingsPath : null;
+            }
+            case 5 :
+                return this.workspaceSettingsResource;
+            case 6 :
+                if (resource) {
+                    return this.getFolderSettingsResource(resource);
+                }
+        }
+        return null;
+    }
+    async createSettingsIfNotExists(target, resource) {
+        if (this.contextService.getWorkbenchState() === 3  && target === 5 ) {
+            const workspaceConfig = this.contextService.getWorkspace().configuration;
+            if (!workspaceConfig) {
+                return;
+            }
+            const content = await this.textFileService.read(workspaceConfig);
+            if (( Object.keys(parse(content.value))).indexOf('settings') === -1) {
+                await this.jsonEditingService.write(resource, [{ path: ['settings'], value: {} }], true);
+            }
+            return undefined;
+        }
+        await this.createIfNotExists(resource, emptyEditableSettingsContent);
+    }
+    async createIfNotExists(resource, contents) {
+        try {
+            await this.textFileService.read(resource, { acceptTextOnly: true });
+        }
+        catch (error) {
+            if (error.fileOperationResult === 1 ) {
+                try {
+                    await this.textFileService.write(resource, contents);
+                    return;
+                }
+                catch (error2) {
+                    throw new Error(localizeWithPath('vs/workbench/services/preferences/browser/preferencesService', 'fail.createSettings', "Unable to create '{0}' ({1}).", this.labelService.getUriLabel(resource, { relative: true }), getErrorMessage(error2)));
+                }
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    getMostCommonlyUsedSettings() {
+        return [
+            'files.autoSave',
+            'editor.fontSize',
+            'editor.fontFamily',
+            'editor.tabSize',
+            'editor.renderWhitespace',
+            'editor.cursorStyle',
+            'editor.multiCursorModifier',
+            'editor.insertSpaces',
+            'editor.wordWrap',
+            'files.exclude',
+            'files.associations',
+            'workbench.editor.enablePreview'
+        ];
+    }
+    async revealSetting(settingKey, edit, editor, settingsResource) {
+        const codeEditor = editor ? getCodeEditor(editor.getControl()) : null;
+        if (!codeEditor) {
+            return;
+        }
+        const settingsModel = await this.createPreferencesEditorModel(settingsResource);
+        if (!settingsModel) {
+            return;
+        }
+        const position = await this.getPositionToReveal(settingKey, edit, settingsModel, codeEditor);
+        if (position) {
+            codeEditor.setPosition(position);
+            codeEditor.revealPositionNearTop(position);
+            codeEditor.focus();
+            if (edit) {
+                SuggestController.get(codeEditor)?.triggerSuggest();
+            }
+        }
+    }
+    async getPositionToReveal(settingKey, edit, settingsModel, codeEditor) {
+        const model = codeEditor.getModel();
+        if (!model) {
+            return null;
+        }
+        const schema = ( Registry.as(Extensions.Configuration)).getConfigurationProperties()[settingKey];
+        const isOverrideProperty = OVERRIDE_PROPERTY_REGEX.test(settingKey);
+        if (!schema && !isOverrideProperty) {
+            return null;
+        }
+        let position = null;
+        const type = schema?.type ?? 'object' ;
+        let setting = settingsModel.getPreference(settingKey);
+        if (!setting && edit) {
+            let defaultValue = (type === 'object' || type === 'array') ? this.configurationService.inspect(settingKey).defaultValue : getDefaultValue(type);
+            defaultValue = defaultValue === undefined && isOverrideProperty ? {} : defaultValue;
+            if (defaultValue !== undefined) {
+                const key = settingsModel instanceof WorkspaceConfigurationEditorModel ? ['settings', settingKey] : [settingKey];
+                await this.jsonEditingService.write(settingsModel.uri, [{ path: key, value: defaultValue }], false);
+                setting = settingsModel.getPreference(settingKey);
+            }
+        }
+        if (setting) {
+            if (edit) {
+                if (isObject(setting.value) || Array.isArray(setting.value)) {
+                    position = { lineNumber: setting.valueRange.startLineNumber, column: setting.valueRange.startColumn + 1 };
+                    codeEditor.setPosition(position);
+                    await CoreEditingCommands.LineBreakInsert.runEditorCommand(null, codeEditor, null);
+                    position = { lineNumber: position.lineNumber + 1, column: model.getLineMaxColumn(position.lineNumber + 1) };
+                    const firstNonWhiteSpaceColumn = model.getLineFirstNonWhitespaceColumn(position.lineNumber);
+                    if (firstNonWhiteSpaceColumn) {
+                        codeEditor.setPosition({ lineNumber: position.lineNumber, column: firstNonWhiteSpaceColumn });
+                        await CoreEditingCommands.LineBreakInsert.runEditorCommand(null, codeEditor, null);
+                        position = { lineNumber: position.lineNumber, column: model.getLineMaxColumn(position.lineNumber) };
+                    }
+                }
+                else {
+                    position = { lineNumber: setting.valueRange.startLineNumber, column: setting.valueRange.endColumn };
+                }
+            }
+            else {
+                position = { lineNumber: setting.keyRange.startLineNumber, column: setting.keyRange.startColumn };
+            }
+        }
+        return position;
+    }
+    dispose() {
+        this._onDispose.fire();
+        super.dispose();
+    }
+};
+PreferencesService = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IEditorGroupsService)),
+    ( __param(2, ITextFileService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, INotificationService)),
+    ( __param(5, IWorkspaceContextService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, IUserDataProfileService)),
+    ( __param(8, IUserDataProfilesService)),
+    ( __param(9, ITextModelService)),
+    ( __param(10, IKeybindingService)),
+    ( __param(11, IModelService)),
+    ( __param(12, IJSONEditingService)),
+    ( __param(13, ILanguageService)),
+    ( __param(14, ILabelService)),
+    ( __param(15, IRemoteAgentService)),
+    ( __param(16, ITextEditorService))
+], PreferencesService));
+export { PreferencesService };

package/vscode/src/vs/workbench/services/quickinput/browser/quickInputService.js

@@ -0,0 +1,37 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { ILayoutService } from '../../../../platform/layout/browser/layoutService.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
+import { QuickInputService as QuickInputService$1 } from '../../../../platform/quickinput/browser/quickInputService.js';
+import '../../../../platform/quickinput/common/quickInput.js';
+import { InQuickPickContextKey } from '../../../browser/quickaccess.js';
+let QuickInputService = class QuickInputService extends QuickInputService$1 {
+    constructor(configurationService, instantiationService, keybindingService, contextKeyService, themeService, layoutService) {
+        super(instantiationService, contextKeyService, themeService, layoutService, configurationService);
+        this.keybindingService = keybindingService;
+        this.inQuickInputContext = InQuickPickContextKey.bindTo(this.contextKeyService);
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.onShow(() => this.inQuickInputContext.set(true)));
+        this._register(this.onHide(() => this.inQuickInputContext.set(false)));
+    }
+    createController() {
+        return super.createController(this.layoutService, {
+            ignoreFocusOut: () => !this.configurationService.getValue('workbench.quickOpen.closeOnFocusLost'),
+            backKeybindingLabel: () => this.keybindingService.lookupKeybinding('workbench.action.quickInputBack')?.getLabel() || undefined,
+        });
+    }
+};
+QuickInputService = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IKeybindingService)),
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IThemeService)),
+    ( __param(5, ILayoutService))
+], QuickInputService));
+export { QuickInputService };

package/vscode/src/vs/workbench/services/remote/browser/browserRemoteResourceHandler.js

@@ -0,0 +1,47 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { VSBuffer } from '../../../../base/common/buffer.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { getMediaOrTextMime } from '../../../../base/common/mime.js';
+import { URI } from '../../../../base/common/uri.js';
+import { FileOperationError, IFileService } from '../../../../platform/files/common/files.js';
+let BrowserRemoteResourceLoader = class BrowserRemoteResourceLoader extends Disposable {
+    constructor(fileService, provider) {
+        super();
+        this.provider = provider;
+        this._register(provider.onDidReceiveRequest(async (request) => {
+            let uri;
+            try {
+                uri = JSON.parse(decodeURIComponent(request.uri.query));
+            }
+            catch {
+                return request.respondWith(404, ( new Uint8Array()), {});
+            }
+            let content;
+            try {
+                content = await fileService.readFile(( URI.from(uri, true)));
+            }
+            catch (e) {
+                const str = VSBuffer.fromString(e.message).buffer;
+                if (e instanceof FileOperationError && e.fileOperationResult === 1 ) {
+                    return request.respondWith(404, str, {});
+                }
+                else {
+                    return request.respondWith(500, str, {});
+                }
+            }
+            const mime = uri.path && getMediaOrTextMime(uri.path);
+            request.respondWith(200, content.value.buffer, mime ? { 'content-type': mime } : {});
+        }));
+    }
+    getResourceUriProvider() {
+        const baseUri = ( URI.parse(document.location.href));
+        return uri => baseUri.with({
+            path: this.provider.path,
+            query: JSON.stringify(uri),
+        });
+    }
+};
+BrowserRemoteResourceLoader = ( __decorate([
+    ( __param(0, IFileService))
+], BrowserRemoteResourceLoader));
+export { BrowserRemoteResourceLoader };