@codingame/monaco-vscode-api 4.1.0 → 4.1.2

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

@@ -1,551 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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 };