@codingame/monaco-vscode-api 1.78.4-next.3 → 1.78.5-next.0

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

@@ -0,0 +1,547 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { getErrorMessage } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { parse } from '../../../../base/common/json.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import * as network from 'monaco-editor/esm/vs/base/common/network.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { CoreEditingCommands } from 'monaco-editor/esm/vs/editor/browser/coreCommands.js';
+import { getCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Extensions, OVERRIDE_PROPERTY_REGEX, getDefaultValue } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/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 'monaco-editor/esm/vs/base/common/types.js';
+import { SuggestController } from 'monaco-editor/esm/vs/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: network.Schemas.vscode, authority: 'defaultsettings', path: '/keybindings.json' }
+        ));
+        this.defaultSettingsRawResource = ( URI.from(
+            { scheme: network.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);
+    }
+    get settingsEditor2Input() {
+        return this.instantiationService.createInstance(SettingsEditor2Input);
+    }
+    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.settingsEditor2Input;
+        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(( nls.localize(
+                '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 = '// ' + ( nls.localize(
+                '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: ( nls.localize('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: ( nls.localize('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 === network.Schemas.vscode && !!uri.path.match(/\/(\d+\/)?settings\.json$/);
+    }
+    isDefaultWorkspaceSettingsResource(uri) {
+        return uri.authority === 'defaultsettings' && uri.scheme === network.Schemas.vscode && !!uri.path.match(/\/(\d+\/)?workspaceSettings\.json$/);
+    }
+    isDefaultFolderSettingsResource(uri) {
+        return uri.authority === 'defaultsettings' && uri.scheme === network.Schemas.vscode && !!uri.path.match(/\/(\d+\/)?resourceSettings\.json$/);
+    }
+    getDefaultSettingsResource(configurationTarget) {
+        switch (configurationTarget) {
+            case 5 :
+                return ( URI.from(
+                    { scheme: network.Schemas.vscode, authority: 'defaultsettings', path: `/workspaceSettings.json` }
+                ));
+            case 6 :
+                return ( URI.from(
+                    { scheme: network.Schemas.vscode, authority: 'defaultsettings', path: `/resourceSettings.json` }
+                ));
+        }
+        return ( URI.from(
+            { scheme: network.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 ) {
+            if (!this._defaultWorkspaceSettingsContentModel) {
+                this._defaultWorkspaceSettingsContentModel = ( new DefaultSettings(this.getMostCommonlyUsedSettings(), target));
+            }
+            return this._defaultWorkspaceSettingsContentModel;
+        }
+        if (target === 6 ) {
+            if (!this._defaultFolderSettingsContentModel) {
+                this._defaultFolderSettingsContentModel = ( new DefaultSettings(this.getMostCommonlyUsedSettings(), target));
+            }
+            return this._defaultFolderSettingsContentModel;
+        }
+        if (!this._defaultUserSettingsContentModel) {
+            this._defaultUserSettingsContentModel = ( 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(nls.localize('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/dist/vscode/vs/workbench/services/preferences/common/preferences.js

@@ -0,0 +1,20 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { DEFAULT_EDITOR_ASSOCIATION } from '../../../common/editor.js';
+var SettingMatchType;
+( (function(SettingMatchType) {
+    SettingMatchType[SettingMatchType["None"] = 0] = "None";
+    SettingMatchType[SettingMatchType["WholeWordMatch"] = 1] = "WholeWordMatch";
+    SettingMatchType[SettingMatchType["KeyMatch"] = 2] = "KeyMatch";
+})(SettingMatchType || (SettingMatchType = {})));
+function validateSettingsEditorOptions(options) {
+    return {
+        ...options,
+        override: DEFAULT_EDITOR_ASSOCIATION.id,
+        pinned: true
+    };
+}
+const IPreferencesService = ( createDecorator('preferencesService'));
+const FOLDER_SETTINGS_PATH = '.vscode/settings.json';
+const DEFAULT_SETTINGS_EDITOR_SETTING = 'workbench.settings.openDefaultSettings';
+const USE_SPLIT_JSON_SETTING = 'workbench.settings.useSplitJSON';
+export { DEFAULT_SETTINGS_EDITOR_SETTING, FOLDER_SETTINGS_PATH, IPreferencesService, SettingMatchType, USE_SPLIT_JSON_SETTING, validateSettingsEditorOptions };

package/dist/vscode/vs/workbench/services/preferences/common/preferencesEditorInput.js

@@ -0,0 +1,37 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { EditorInput } from '../../../common/editor/editorInput.js';
+import { IPreferencesService } from './preferences.js';
+let SettingsEditor2Input = class SettingsEditor2Input extends EditorInput {
+    constructor(_preferencesService) {
+        super();
+        this.resource = ( URI.from({
+            scheme: Schemas.vscodeSettings,
+            path: `settingseditor`
+        }));
+        this._settingsModel = _preferencesService.createSettings2EditorModel();
+    }
+    matches(otherInput) {
+        return super.matches(otherInput) || otherInput instanceof SettingsEditor2Input;
+    }
+    get typeId() {
+        return SettingsEditor2Input.ID;
+    }
+    getName() {
+        return ( nls.localize('settingsEditor2InputName', "Settings"));
+    }
+    async resolve() {
+        return this._settingsModel;
+    }
+    dispose() {
+        this._settingsModel.dispose();
+        super.dispose();
+    }
+};
+SettingsEditor2Input.ID = 'workbench.input.settings2';
+SettingsEditor2Input = ( __decorate([
+    ( __param(0, IPreferencesService))
+], SettingsEditor2Input));
+export { SettingsEditor2Input };