@codingame/monaco-vscode-api 1.82.4-next.1 → 1.82.5-next.0

package/vscode/src/vs/workbench/contrib/preferences/browser/settingsEditor2.js

@@ -1,1477 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
-import * as aria from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
-import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
-import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
-import { Button } from 'monaco-editor/esm/vs/base/browser/ui/button/button.js';
-import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
-import { Delayer, ThrottledDelayer, timeout, IntervalTimer } from 'monaco-editor/esm/vs/base/common/async.js';
-import { CancellationToken, CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
-import { fromNow } from '../../../../base/common/date.js';
-import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
-import { DisposableStore, dispose, Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import * as platform from 'monaco-editor/esm/vs/base/common/platform.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import './media/settingsEditor2.css.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { asCssVariable, badgeBackground, badgeForeground, contrastBorder, editorForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
-import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
-import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
-import { IUserDataSyncEnablementService, IUserDataSyncService } from '../../../../platform/userDataSync/common/userDataSync.js';
-import { EditorPane } from '../../../browser/parts/editor/editorPane.js';
-import { SuggestEnabledInput } from '../../codeEditor/browser/suggestEnabledInput/suggestEnabledInput.js';
-import { SettingsTargetsWidget } from './preferencesWidgets.js';
-import { getCommonlyUsedData, tocData } from './settingsLayout.js';
-import { AbstractSettingRenderer, SettingTreeRenderers, SettingsTree, resolveSettingsTree, createTocTreeForExtensionSettings, resolveConfiguredUntrustedSettings } from './settingsTree.js';
-import { SettingsTreeSettingElement, parseQuery, SettingsTreeModel, SearchResultModel, SettingsTreeGroupElement } from './settingsTreeModels.js';
-import { TOCTreeModel, TOCTree, createTOCIterator } from './tocTree.js';
-import { MODIFIED_SETTING_TAG, REQUIRE_TRUSTED_WORKSPACE_SETTING_TAG, WORKSPACE_TRUST_SETTING_TAG, ID_SETTING_TAG, EXTENSION_SETTING_TAG, FEATURE_SETTING_TAG, POLICY_SETTING_TAG, CONTEXT_SETTINGS_EDITOR, CONTEXT_SETTINGS_SEARCH_FOCUS, CONTEXT_TOC_ROW_FOCUS, CONTEXT_SETTINGS_ROW_FOCUS, LANGUAGE_SETTING_TAG, SETTINGS_EDITOR_COMMAND_CLEAR_SEARCH_RESULTS, SETTINGS_EDITOR_COMMAND_SUGGEST_FILTERS, getExperimentalExtensionToggleData, IPreferencesSearchService } from '../common/preferences.js';
-import { settingsTextInputBorder, settingsHeaderBorder, settingsSashBorder } from '../common/settingsEditorColorRegistry.js';
-import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
-import { SettingValueType, validateSettingsEditorOptions, SettingMatchType, IPreferencesService } from '../../../services/preferences/common/preferences.js';
-import { Settings2EditorModel, nullRange } from '../../../services/preferences/common/preferencesModels.js';
-import { IUserDataSyncWorkbenchService } from '../../../services/userDataSync/common/userDataSync.js';
-import { preferencesClearInputIcon, preferencesFilterIcon } from './preferencesIcons.js';
-import { IWorkspaceTrustManagementService } from 'monaco-editor/esm/vs/platform/workspace/common/workspaceTrust.js';
-import { IWorkbenchConfigurationService } from '../../../services/configuration/common/configuration.js';
-import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
-import { IExtensionService } from '../../../services/extensions/common/extensions.js';
-import { SplitView, Sizing } from 'monaco-editor/esm/vs/base/browser/ui/splitview/splitview.js';
-import { Color } from 'monaco-editor/esm/vs/base/common/color.js';
-import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
-import { SettingsSearchFilterDropdownMenuActionViewItem } from './settingsSearchMenu.js';
-import { IExtensionManagementService, IExtensionGalleryService } from '../../../../platform/extensionManagement/common/extensionManagement.js';
-import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { defaultButtonStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
-import { IWorkbenchAssignmentService } from '../../../services/assignment/common/assignmentService.js';
-import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
-import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
-import { registerNavigableContainer } from '../../../browser/actions/widgetNavigationCommands.js';
-import { IEditorProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
-var SettingsEditor2_1;
-function createGroupIterator(group) {
-    return ( Iterable.map(group.children, g => {
-        return {
-            element: g,
-            children: g instanceof SettingsTreeGroupElement ?
-                createGroupIterator(g) :
-                undefined
-        };
-    }));
-}
-const $ = dom.$;
-const searchBoxLabel = ( localize('SearchSettings.AriaLabel', "Search settings"));
-const SETTINGS_EDITOR_STATE_KEY = 'settingsEditorState';
-let SettingsEditor2 = class SettingsEditor2 extends EditorPane {
-    static { SettingsEditor2_1 = this; }
-    static { this.ID = 'workbench.editor.settings2'; }
-    static { this.NUM_INSTANCES = 0; }
-    static { this.SEARCH_DEBOUNCE = 200; }
-    static { this.SETTING_UPDATE_FAST_DEBOUNCE = 200; }
-    static { this.SETTING_UPDATE_SLOW_DEBOUNCE = 1000; }
-    static { this.CONFIG_SCHEMA_UPDATE_DELAYER = 500; }
-    static { this.TOC_MIN_WIDTH = 100; }
-    static { this.TOC_RESET_WIDTH = 200; }
-    static { this.EDITOR_MIN_WIDTH = 500; }
-    static { this.NARROW_TOTAL_WIDTH = SettingsEditor2_1.TOC_RESET_WIDTH + SettingsEditor2_1.EDITOR_MIN_WIDTH; }
-    static { this.SUGGESTIONS = [
-        `@${MODIFIED_SETTING_TAG}`,
-        '@tag:notebookLayout',
-        '@tag:notebookOutputLayout',
-        `@tag:${REQUIRE_TRUSTED_WORKSPACE_SETTING_TAG}`,
-        `@tag:${WORKSPACE_TRUST_SETTING_TAG}`,
-        '@tag:sync',
-        '@tag:usesOnlineServices',
-        '@tag:telemetry',
-        '@tag:accessibility',
-        `@${ID_SETTING_TAG}`,
-        `@${EXTENSION_SETTING_TAG}`,
-        `@${FEATURE_SETTING_TAG}scm`,
-        `@${FEATURE_SETTING_TAG}explorer`,
-        `@${FEATURE_SETTING_TAG}search`,
-        `@${FEATURE_SETTING_TAG}debug`,
-        `@${FEATURE_SETTING_TAG}extensions`,
-        `@${FEATURE_SETTING_TAG}terminal`,
-        `@${FEATURE_SETTING_TAG}task`,
-        `@${FEATURE_SETTING_TAG}problems`,
-        `@${FEATURE_SETTING_TAG}output`,
-        `@${FEATURE_SETTING_TAG}comments`,
-        `@${FEATURE_SETTING_TAG}remote`,
-        `@${FEATURE_SETTING_TAG}timeline`,
-        `@${FEATURE_SETTING_TAG}notebook`,
-        `@${POLICY_SETTING_TAG}`
-    ]; }
-    static shouldSettingUpdateFast(type) {
-        if (Array.isArray(type)) {
-            return false;
-        }
-        return type === SettingValueType.Enum ||
-            type === SettingValueType.Array ||
-            type === SettingValueType.BooleanObject ||
-            type === SettingValueType.Object ||
-            type === SettingValueType.Complex ||
-            type === SettingValueType.Boolean ||
-            type === SettingValueType.Exclude ||
-            type === SettingValueType.Include;
-    }
-    constructor(telemetryService, configurationService, textResourceConfigurationService, themeService, preferencesService, instantiationService, preferencesSearchService, logService, contextKeyService, storageService, editorGroupService, userDataSyncWorkbenchService, userDataSyncEnablementService, workspaceTrustManagementService, extensionService, languageService, extensionManagementService, workbenchAssignmentService, productService, environmentService, extensionGalleryService, editorProgressService) {
-        super(SettingsEditor2_1.ID, telemetryService, themeService, storageService);
-        this.configurationService = configurationService;
-        this.preferencesService = preferencesService;
-        this.instantiationService = instantiationService;
-        this.preferencesSearchService = preferencesSearchService;
-        this.logService = logService;
-        this.storageService = storageService;
-        this.editorGroupService = editorGroupService;
-        this.userDataSyncWorkbenchService = userDataSyncWorkbenchService;
-        this.userDataSyncEnablementService = userDataSyncEnablementService;
-        this.workspaceTrustManagementService = workspaceTrustManagementService;
-        this.extensionService = extensionService;
-        this.languageService = languageService;
-        this.workbenchAssignmentService = workbenchAssignmentService;
-        this.productService = productService;
-        this.environmentService = environmentService;
-        this.extensionGalleryService = extensionGalleryService;
-        this.editorProgressService = editorProgressService;
-        this.searchInProgress = null;
-        this.pendingSettingUpdate = null;
-        this._searchResultModel = null;
-        this.searchResultLabel = null;
-        this.lastSyncedLabel = null;
-        this._currentFocusContext = 0 ;
-        this.hasWarnedMissingSettings = false;
-        this.tocFocusedElement = null;
-        this.treeFocusedElement = null;
-        this.settingsTreeScrollTop = 0;
-        this.installedExtensionIds = [];
-        this.delayedFilterLogging = ( new Delayer(1000));
-        this.localSearchDelayer = ( new Delayer(300));
-        this.remoteSearchThrottle = ( new ThrottledDelayer(200));
-        this.viewState = { settingsTarget: 3  };
-        this.settingFastUpdateDelayer = ( new Delayer(SettingsEditor2_1.SETTING_UPDATE_FAST_DEBOUNCE));
-        this.settingSlowUpdateDelayer = ( new Delayer(SettingsEditor2_1.SETTING_UPDATE_SLOW_DEBOUNCE));
-        this.searchInputDelayer = ( new Delayer(SettingsEditor2_1.SEARCH_DEBOUNCE));
-        this.updatedConfigSchemaDelayer = ( new Delayer(SettingsEditor2_1.CONFIG_SCHEMA_UPDATE_DELAYER));
-        this.inSettingsEditorContextKey = CONTEXT_SETTINGS_EDITOR.bindTo(contextKeyService);
-        this.searchFocusContextKey = CONTEXT_SETTINGS_SEARCH_FOCUS.bindTo(contextKeyService);
-        this.tocRowFocused = CONTEXT_TOC_ROW_FOCUS.bindTo(contextKeyService);
-        this.settingRowFocused = CONTEXT_SETTINGS_ROW_FOCUS.bindTo(contextKeyService);
-        this.scheduledRefreshes = ( new Map());
-        this.editorMemento = this.getEditorMemento(editorGroupService, textResourceConfigurationService, SETTINGS_EDITOR_STATE_KEY);
-        this._register(configurationService.onDidChangeConfiguration(e => {
-            if (e.source !== 7 ) {
-                this.onConfigUpdate(e.affectedKeys);
-            }
-        }));
-        this._register(workspaceTrustManagementService.onDidChangeTrust(() => {
-            this.searchResultModel?.updateWorkspaceTrust(workspaceTrustManagementService.isWorkspaceTrusted());
-            if (this.settingsTreeModel) {
-                this.settingsTreeModel.updateWorkspaceTrust(workspaceTrustManagementService.isWorkspaceTrusted());
-                this.renderTree();
-            }
-        }));
-        this._register(configurationService.onDidChangeRestrictedSettings(e => {
-            if (e.default.length && this.currentSettingsModel) {
-                this.updateElementsByKey(( new Set(e.default)));
-            }
-        }));
-        this.modelDisposables = this._register(( new DisposableStore()));
-        if (!SettingsEditor2_1.SUGGESTIONS.includes(`@${LANGUAGE_SETTING_TAG}`)) {
-            SettingsEditor2_1.SUGGESTIONS.push(`@${LANGUAGE_SETTING_TAG}`);
-        }
-        extensionManagementService.getInstalled().then(extensions => {
-            this.installedExtensionIds = ( extensions
-                .filter(ext => ext.manifest && ext.manifest.contributes && ext.manifest.contributes.configuration)
-                .map(ext => ext.identifier.id));
-        });
-    }
-    get minimumWidth() { return SettingsEditor2_1.EDITOR_MIN_WIDTH; }
-    get maximumWidth() { return Number.POSITIVE_INFINITY; }
-    get minimumHeight() { return 180; }
-    set minimumWidth(value) { }
-    set maximumWidth(value) { }
-    get currentSettingsModel() {
-        return this.searchResultModel || this.settingsTreeModel;
-    }
-    get searchResultModel() {
-        return this._searchResultModel;
-    }
-    set searchResultModel(value) {
-        this._searchResultModel = value;
-        this.rootElement.classList.toggle('search-mode', !!this._searchResultModel);
-    }
-    get focusedSettingDOMElement() {
-        const focused = this.settingsTree.getFocus()[0];
-        if (!(focused instanceof SettingsTreeSettingElement)) {
-            return;
-        }
-        return this.settingRenderers.getDOMElementsForSettingKey(this.settingsTree.getHTMLElement(), focused.setting.key)[0];
-    }
-    get currentFocusContext() {
-        return this._currentFocusContext;
-    }
-    createEditor(parent) {
-        parent.setAttribute('tabindex', '-1');
-        this.rootElement = dom.append(parent, $('.settings-editor', { tabindex: '-1' }));
-        this.createHeader(this.rootElement);
-        this.createBody(this.rootElement);
-        this.addCtrlAInterceptor(this.rootElement);
-        this.updateStyles();
-        this._register(registerNavigableContainer({
-            focusNotifiers: [this],
-            focusNextWidget: () => {
-                if (this.searchWidget.inputWidget.hasWidgetFocus()) {
-                    this.focusTOC();
-                }
-            },
-            focusPreviousWidget: () => {
-                if (!this.searchWidget.inputWidget.hasWidgetFocus()) {
-                    this.focusSearch();
-                }
-            }
-        }));
-    }
-    async setInput(input, options, context, token) {
-        this.inSettingsEditorContextKey.set(true);
-        await super.setInput(input, options, context, token);
-        await timeout(0);
-        if (!this.input) {
-            return;
-        }
-        const model = await this.input.resolve(options);
-        if (token.isCancellationRequested || !(model instanceof Settings2EditorModel)) {
-            return;
-        }
-        this.modelDisposables.clear();
-        this.modelDisposables.add(model.onDidChangeGroups(() => {
-            this.updatedConfigSchemaDelayer.trigger(() => {
-                this.onConfigUpdate(undefined, false, true);
-            });
-        }));
-        this.defaultSettingsEditorModel = model;
-        options = options || validateSettingsEditorOptions({});
-        if (!this.viewState.settingsTarget || !this.settingsTargetsWidget.settingsTarget) {
-            const optionsHasViewStateTarget = options.viewState && options.viewState.settingsTarget;
-            if (!options.target && !optionsHasViewStateTarget) {
-                options.target = 3 ;
-            }
-        }
-        this._setOptions(options);
-        this.onConfigUpdate(undefined, true).then(() => {
-            this._register(input.onWillDispose(() => {
-                this.searchWidget.setValue('');
-            }));
-            this.updateTreeScrollSync();
-        });
-    }
-    restoreCachedState() {
-        const cachedState = this.group && this.input && this.editorMemento.loadEditorState(this.group, this.input);
-        if (cachedState && typeof cachedState.target === 'object') {
-            cachedState.target = URI.revive(cachedState.target);
-        }
-        if (cachedState) {
-            const settingsTarget = cachedState.target;
-            this.settingsTargetsWidget.settingsTarget = settingsTarget;
-            this.viewState.settingsTarget = settingsTarget;
-            this.searchWidget.setValue(cachedState.searchQuery);
-        }
-        if (this.input) {
-            this.editorMemento.clearEditorState(this.input, this.group);
-        }
-        return cachedState ?? null;
-    }
-    getViewState() {
-        return this.viewState;
-    }
-    setOptions(options) {
-        super.setOptions(options);
-        if (options) {
-            this._setOptions(options);
-        }
-    }
-    _setOptions(options) {
-        if (options.focusSearch && !platform.isIOS) {
-            this.focusSearch();
-        }
-        const recoveredViewState = options.viewState ?
-            options.viewState : undefined;
-        const query = recoveredViewState?.query ?? options.query;
-        if (query !== undefined) {
-            this.searchWidget.setValue(query);
-            this.viewState.query = query;
-        }
-        const target = options.folderUri ?? recoveredViewState?.settingsTarget ?? options.target;
-        if (target) {
-            this.settingsTargetsWidget.settingsTarget = target;
-            this.viewState.settingsTarget = target;
-        }
-    }
-    clearInput() {
-        this.inSettingsEditorContextKey.set(false);
-        super.clearInput();
-    }
-    layout(dimension) {
-        this.dimension = dimension;
-        if (!this.isVisible()) {
-            return;
-        }
-        this.layoutSplitView(dimension);
-        const innerWidth = Math.min(this.headerContainer.clientWidth, dimension.width) - 24 * 2;
-        const monacoWidth = innerWidth - 10 - this.countElement.clientWidth - this.controlsElement.clientWidth - 12;
-        this.searchWidget.layout(new dom.Dimension(monacoWidth, 20));
-        this.rootElement.classList.toggle('narrow-width', dimension.width < SettingsEditor2_1.NARROW_TOTAL_WIDTH);
-    }
-    focus() {
-        if (this._currentFocusContext === 0 ) {
-            if (!platform.isIOS) {
-                this.focusSearch();
-            }
-        }
-        else if (this._currentFocusContext === 3 ) {
-            const element = this.focusedSettingDOMElement;
-            if (element) {
-                const control = element.querySelector(AbstractSettingRenderer.CONTROL_SELECTOR);
-                if (control) {
-                    control.focus();
-                    return;
-                }
-            }
-        }
-        else if (this._currentFocusContext === 2 ) {
-            this.settingsTree.domFocus();
-        }
-        else if (this._currentFocusContext === 1 ) {
-            this.tocTree.domFocus();
-        }
-    }
-    setEditorVisible(visible, group) {
-        super.setEditorVisible(visible, group);
-        if (!visible) {
-            setTimeout(() => {
-                this.searchWidget.onHide();
-            }, 0);
-        }
-    }
-    focusSettings(focusSettingInput = false) {
-        const focused = this.settingsTree.getFocus();
-        if (!focused.length) {
-            this.settingsTree.focusFirst();
-        }
-        this.settingsTree.domFocus();
-        if (focusSettingInput) {
-            const controlInFocusedRow = this.settingsTree.getHTMLElement().querySelector(`.focused ${AbstractSettingRenderer.CONTROL_SELECTOR}`);
-            if (controlInFocusedRow) {
-                controlInFocusedRow.focus();
-            }
-        }
-    }
-    focusTOC() {
-        this.tocTree.domFocus();
-    }
-    showContextMenu() {
-        const focused = this.settingsTree.getFocus()[0];
-        const rowElement = this.focusedSettingDOMElement;
-        if (rowElement && focused instanceof SettingsTreeSettingElement) {
-            this.settingRenderers.showContextMenu(focused, rowElement);
-        }
-    }
-    focusSearch(filter, selectAll = true) {
-        if (filter && this.searchWidget) {
-            this.searchWidget.setValue(filter);
-        }
-        this.searchWidget.focus(selectAll);
-    }
-    clearSearchResults() {
-        this.searchWidget.setValue('');
-        this.focusSearch();
-    }
-    clearSearchFilters() {
-        const query = this.searchWidget.getValue();
-        const splitQuery = query.split(' ').filter(word => {
-            return word.length && !( SettingsEditor2_1.SUGGESTIONS.some(suggestion => word.startsWith(suggestion)));
-        });
-        this.searchWidget.setValue(splitQuery.join(' '));
-    }
-    updateInputAriaLabel() {
-        let label = searchBoxLabel;
-        if (this.searchResultLabel) {
-            label += `. ${this.searchResultLabel}`;
-        }
-        if (this.lastSyncedLabel) {
-            label += `. ${this.lastSyncedLabel}`;
-        }
-        this.searchWidget.updateAriaLabel(label);
-    }
-    createHeader(parent) {
-        this.headerContainer = dom.append(parent, $('.settings-header'));
-        const searchContainer = dom.append(this.headerContainer, $('.search-container'));
-        const clearInputAction = ( new Action(SETTINGS_EDITOR_COMMAND_CLEAR_SEARCH_RESULTS, ( localize('clearInput', "Clear Settings Search Input")), ThemeIcon.asClassName(preferencesClearInputIcon), false, async () => this.clearSearchResults()));
-        const filterAction = ( new Action(SETTINGS_EDITOR_COMMAND_SUGGEST_FILTERS, ( localize('filterInput', "Filter Settings")), ThemeIcon.asClassName(preferencesFilterIcon)));
-        this.searchWidget = this._register(this.instantiationService.createInstance(SuggestEnabledInput, `${SettingsEditor2_1.ID}.searchbox`, searchContainer, {
-            triggerCharacters: ['@', ':'],
-            provideResults: (query) => {
-                const queryParts = query.split(/\s/g);
-                if (queryParts[queryParts.length - 1].startsWith(`@${LANGUAGE_SETTING_TAG}`)) {
-                    const sortedLanguages = ( this.languageService.getRegisteredLanguageIds().map(languageId => {
-                        return `@${LANGUAGE_SETTING_TAG}${languageId} `;
-                    })).sort();
-                    return sortedLanguages.filter(langFilter => !query.includes(langFilter));
-                }
-                else if (queryParts[queryParts.length - 1].startsWith(`@${EXTENSION_SETTING_TAG}`)) {
-                    const installedExtensionsTags = ( this.installedExtensionIds.map(extensionId => {
-                        return `@${EXTENSION_SETTING_TAG}${extensionId} `;
-                    })).sort();
-                    return installedExtensionsTags.filter(extFilter => !query.includes(extFilter));
-                }
-                else if (queryParts[queryParts.length - 1].startsWith('@')) {
-                    return ( SettingsEditor2_1.SUGGESTIONS.filter(tag => !query.includes(tag)).map(tag => tag.endsWith(':') ? tag : tag + ' '));
-                }
-                return [];
-            }
-        }, searchBoxLabel, 'settingseditor:searchinput' + SettingsEditor2_1.NUM_INSTANCES++, {
-            placeholderText: searchBoxLabel,
-            focusContextKey: this.searchFocusContextKey,
-            styleOverrides: {
-                inputBorder: settingsTextInputBorder
-            }
-        }));
-        this._register(this.searchWidget.onDidFocus(() => {
-            this._currentFocusContext = 0 ;
-        }));
-        this.countElement = dom.append(searchContainer, dom.$('.settings-count-widget.monaco-count-badge.long'));
-        this.countElement.style.backgroundColor = asCssVariable(badgeBackground);
-        this.countElement.style.color = asCssVariable(badgeForeground);
-        this.countElement.style.border = `1px solid ${asCssVariable(contrastBorder)}`;
-        this._register(this.searchWidget.onInputDidChange(() => {
-            const searchVal = this.searchWidget.getValue();
-            clearInputAction.enabled = !!searchVal;
-            this.searchInputDelayer.trigger(() => this.onSearchInputChanged());
-        }));
-        const headerControlsContainer = dom.append(this.headerContainer, $('.settings-header-controls'));
-        headerControlsContainer.style.borderColor = asCssVariable(settingsHeaderBorder);
-        const targetWidgetContainer = dom.append(headerControlsContainer, $('.settings-target-container'));
-        this.settingsTargetsWidget = this._register(this.instantiationService.createInstance(SettingsTargetsWidget, targetWidgetContainer, { enableRemoteSettings: true }));
-        this.settingsTargetsWidget.settingsTarget = 3 ;
-        this.settingsTargetsWidget.onDidTargetChange(target => this.onDidSettingsTargetChange(target));
-        this._register(dom.addDisposableListener(targetWidgetContainer, dom.EventType.KEY_DOWN, e => {
-            const event = ( new StandardKeyboardEvent(e));
-            if (event.keyCode === 18 ) {
-                this.focusSettings();
-            }
-        }));
-        if (this.userDataSyncWorkbenchService.enabled && this.userDataSyncEnablementService.canToggleEnablement()) {
-            const syncControls = this._register(this.instantiationService.createInstance(SyncControls, headerControlsContainer));
-            this._register(syncControls.onDidChangeLastSyncedLabel(lastSyncedLabel => {
-                this.lastSyncedLabel = lastSyncedLabel;
-                this.updateInputAriaLabel();
-            }));
-        }
-        this.controlsElement = dom.append(searchContainer, dom.$('.settings-clear-widget'));
-        const actionBar = this._register(( new ActionBar(this.controlsElement, {
-            animated: false,
-            actionViewItemProvider: (action) => {
-                if (action.id === filterAction.id) {
-                    return this.instantiationService.createInstance(SettingsSearchFilterDropdownMenuActionViewItem, action, this.actionRunner, this.searchWidget);
-                }
-                return undefined;
-            }
-        })));
-        actionBar.push([clearInputAction, filterAction], { label: false, icon: true });
-    }
-    onDidSettingsTargetChange(target) {
-        this.viewState.settingsTarget = target;
-        this.onConfigUpdate(undefined, true);
-    }
-    onDidClickSetting(evt, recursed) {
-        const targetElement = this.currentSettingsModel.getElementsByName(evt.targetKey)?.[0];
-        let revealFailed = false;
-        if (targetElement) {
-            let sourceTop = 0.5;
-            try {
-                const _sourceTop = this.settingsTree.getRelativeTop(evt.source);
-                if (_sourceTop !== null) {
-                    sourceTop = _sourceTop;
-                }
-            }
-            catch {
-            }
-            if (this.viewState.filterToCategory && evt.source.displayCategory !== targetElement.displayCategory) {
-                this.tocTree.setFocus([]);
-            }
-            try {
-                this.settingsTree.reveal(targetElement, sourceTop);
-            }
-            catch (_) {
-                revealFailed = true;
-            }
-            if (!revealFailed) {
-                setTimeout(() => {
-                    this.settingsTree.setFocus([targetElement]);
-                }, 50);
-                const domElements = this.settingRenderers.getDOMElementsForSettingKey(this.settingsTree.getHTMLElement(), evt.targetKey);
-                if (domElements && domElements[0]) {
-                    const control = domElements[0].querySelector(AbstractSettingRenderer.CONTROL_SELECTOR);
-                    if (control) {
-                        control.focus();
-                    }
-                }
-            }
-        }
-        if (!recursed && (!targetElement || revealFailed)) {
-            const p = this.triggerSearch('');
-            p.then(() => {
-                this.searchWidget.setValue('');
-                this.onDidClickSetting(evt, true);
-            });
-        }
-    }
-    switchToSettingsFile() {
-        const query = parseQuery(this.searchWidget.getValue()).query;
-        return this.openSettingsFile({ query });
-    }
-    async openSettingsFile(options) {
-        const currentSettingsTarget = this.settingsTargetsWidget.settingsTarget;
-        const openOptions = { jsonEditor: true, ...options };
-        if (currentSettingsTarget === 3 ) {
-            if (options?.revealSetting) {
-                const configurationProperties = ( Registry.as(Extensions.Configuration)).getConfigurationProperties();
-                const configurationScope = configurationProperties[options?.revealSetting.key]?.scope;
-                if (configurationScope === 1 ) {
-                    return this.preferencesService.openApplicationSettings(openOptions);
-                }
-            }
-            return this.preferencesService.openUserSettings(openOptions);
-        }
-        else if (currentSettingsTarget === 4 ) {
-            return this.preferencesService.openRemoteSettings(openOptions);
-        }
-        else if (currentSettingsTarget === 5 ) {
-            return this.preferencesService.openWorkspaceSettings(openOptions);
-        }
-        else if (URI.isUri(currentSettingsTarget)) {
-            return this.preferencesService.openFolderSettings({ folderUri: currentSettingsTarget, ...openOptions });
-        }
-        return undefined;
-    }
-    createBody(parent) {
-        this.bodyContainer = dom.append(parent, $('.settings-body'));
-        this.noResultsMessage = dom.append(this.bodyContainer, $('.no-results-message'));
-        this.noResultsMessage.innerText = ( localize('noResults', "No Settings Found"));
-        this.clearFilterLinkContainer = $('span.clear-search-filters');
-        this.clearFilterLinkContainer.textContent = ' - ';
-        const clearFilterLink = dom.append(this.clearFilterLinkContainer, $('a.pointer.prominent', { tabindex: 0 }, ( localize('clearSearchFilters', 'Clear Filters'))));
-        this._register(dom.addDisposableListener(clearFilterLink, dom.EventType.CLICK, (e) => {
-            dom.EventHelper.stop(e, false);
-            this.clearSearchFilters();
-        }));
-        dom.append(this.noResultsMessage, this.clearFilterLinkContainer);
-        this.noResultsMessage.style.color = asCssVariable(editorForeground);
-        this.tocTreeContainer = $('.settings-toc-container');
-        this.settingsTreeContainer = $('.settings-tree-container');
-        this.createTOC(this.tocTreeContainer);
-        this.createSettingsTree(this.settingsTreeContainer);
-        this.splitView = ( new SplitView(this.bodyContainer, {
-            orientation: 1 ,
-            proportionalLayout: true
-        }));
-        const startingWidth = this.storageService.getNumber('settingsEditor2.splitViewWidth', 0 , SettingsEditor2_1.TOC_RESET_WIDTH);
-        this.splitView.addView({
-            onDidChange: Event.None,
-            element: this.tocTreeContainer,
-            minimumSize: SettingsEditor2_1.TOC_MIN_WIDTH,
-            maximumSize: Number.POSITIVE_INFINITY,
-            layout: (width, _, height) => {
-                this.tocTreeContainer.style.width = `${width}px`;
-                this.tocTree.layout(height, width);
-            }
-        }, startingWidth, undefined, true);
-        this.splitView.addView({
-            onDidChange: Event.None,
-            element: this.settingsTreeContainer,
-            minimumSize: SettingsEditor2_1.EDITOR_MIN_WIDTH,
-            maximumSize: Number.POSITIVE_INFINITY,
-            layout: (width, _, height) => {
-                this.settingsTreeContainer.style.width = `${width}px`;
-                this.settingsTree.layout(height, width);
-            }
-        }, Sizing.Distribute, undefined, true);
-        this._register(this.splitView.onDidSashReset(() => {
-            const totalSize = this.splitView.getViewSize(0) + this.splitView.getViewSize(1);
-            this.splitView.resizeView(0, SettingsEditor2_1.TOC_RESET_WIDTH);
-            this.splitView.resizeView(1, totalSize - SettingsEditor2_1.TOC_RESET_WIDTH);
-        }));
-        this._register(this.splitView.onDidSashChange(() => {
-            const width = this.splitView.getViewSize(0);
-            this.storageService.store('settingsEditor2.splitViewWidth', width, 0 , 0 );
-        }));
-        const borderColor = this.theme.getColor(settingsSashBorder);
-        this.splitView.style({ separatorBorder: borderColor });
-    }
-    addCtrlAInterceptor(container) {
-        this._register(dom.addStandardDisposableListener(container, dom.EventType.KEY_DOWN, (e) => {
-            if (e.keyCode === 31  &&
-                (platform.isMacintosh ? e.metaKey : e.ctrlKey) &&
-                e.target.tagName !== 'TEXTAREA' &&
-                e.target.tagName !== 'INPUT') {
-                e.browserEvent.stopPropagation();
-                e.browserEvent.preventDefault();
-            }
-        }));
-    }
-    createTOC(container) {
-        this.tocTreeModel = this.instantiationService.createInstance(TOCTreeModel, this.viewState);
-        this.tocTree = this._register(this.instantiationService.createInstance(TOCTree, dom.append(container, $('.settings-toc-wrapper', {
-            'role': 'navigation',
-            'aria-label': ( localize('settings', "Settings")),
-        })), this.viewState));
-        this._register(this.tocTree.onDidFocus(() => {
-            this._currentFocusContext = 1 ;
-        }));
-        this._register(this.tocTree.onDidChangeFocus(e => {
-            const element = e.elements?.[0] ?? null;
-            if (this.tocFocusedElement === element) {
-                return;
-            }
-            this.tocFocusedElement = element;
-            this.tocTree.setSelection(element ? [element] : []);
-            if (this.searchResultModel) {
-                if (this.viewState.filterToCategory !== element) {
-                    this.viewState.filterToCategory = element ?? undefined;
-                    this.renderTree(undefined, true);
-                    this.settingsTree.scrollTop = 0;
-                }
-            }
-            else if (element && (!e.browserEvent || !e.browserEvent.fromScroll)) {
-                this.settingsTree.reveal(element, 0);
-                this.settingsTree.setFocus([element]);
-            }
-        }));
-        this._register(this.tocTree.onDidFocus(() => {
-            this.tocRowFocused.set(true);
-        }));
-        this._register(this.tocTree.onDidBlur(() => {
-            this.tocRowFocused.set(false);
-        }));
-    }
-    applyFilter(filter) {
-        if (this.searchWidget && !this.searchWidget.getValue().includes(filter)) {
-            const newQuery = `${filter} ${this.searchWidget.getValue().trimStart()}`;
-            this.focusSearch(newQuery, false);
-        }
-    }
-    removeLanguageFilters() {
-        if (this.searchWidget && this.searchWidget.getValue().includes(`@${LANGUAGE_SETTING_TAG}`)) {
-            const query = this.searchWidget.getValue().split(' ');
-            const newQuery = query.filter(word => !word.startsWith(`@${LANGUAGE_SETTING_TAG}`)).join(' ');
-            this.focusSearch(newQuery, false);
-        }
-    }
-    createSettingsTree(container) {
-        this.settingRenderers = this.instantiationService.createInstance(SettingTreeRenderers);
-        this._register(this.settingRenderers.onDidChangeSetting(e => this.onDidChangeSetting(e.key, e.value, e.type, e.manualReset, e.scope)));
-        this._register(this.settingRenderers.onDidOpenSettings(settingKey => {
-            this.openSettingsFile({ revealSetting: { key: settingKey, edit: true } });
-        }));
-        this._register(this.settingRenderers.onDidClickSettingLink(settingName => this.onDidClickSetting(settingName)));
-        this._register(this.settingRenderers.onDidFocusSetting(element => {
-            this.settingsTree.setFocus([element]);
-            this._currentFocusContext = 3 ;
-            this.settingRowFocused.set(false);
-        }));
-        this._register(this.settingRenderers.onDidChangeSettingHeight((params) => {
-            const { element, height } = params;
-            try {
-                this.settingsTree.updateElementHeight(element, height);
-            }
-            catch (e) {
-            }
-        }));
-        this._register(this.settingRenderers.onApplyFilter((filter) => this.applyFilter(filter)));
-        this._register(this.settingRenderers.onDidClickOverrideElement((element) => {
-            this.removeLanguageFilters();
-            if (element.language) {
-                this.applyFilter(`@${LANGUAGE_SETTING_TAG}${element.language}`);
-            }
-            if (element.scope === 'workspace') {
-                this.settingsTargetsWidget.updateTarget(5 );
-            }
-            else if (element.scope === 'user') {
-                this.settingsTargetsWidget.updateTarget(3 );
-            }
-            else if (element.scope === 'remote') {
-                this.settingsTargetsWidget.updateTarget(4 );
-            }
-            this.applyFilter(`@${ID_SETTING_TAG}${element.settingKey}`);
-        }));
-        this.settingsTree = this._register(this.instantiationService.createInstance(SettingsTree, container, this.viewState, this.settingRenderers.allRenderers));
-        this._register(this.settingsTree.onDidScroll(() => {
-            if (this.settingsTree.scrollTop === this.settingsTreeScrollTop) {
-                return;
-            }
-            this.settingsTreeScrollTop = this.settingsTree.scrollTop;
-            setTimeout(() => {
-                this.updateTreeScrollSync();
-            }, 0);
-        }));
-        this._register(this.settingsTree.onDidFocus(() => {
-            const classList = document.activeElement?.classList;
-            if (classList && classList.contains('monaco-list') && classList.contains('settings-editor-tree')) {
-                this._currentFocusContext = 2 ;
-                this.settingRowFocused.set(true);
-                this.treeFocusedElement ??= this.settingsTree.firstVisibleElement ?? null;
-                if (this.treeFocusedElement) {
-                    this.treeFocusedElement.tabbable = true;
-                }
-            }
-        }));
-        this._register(this.settingsTree.onDidBlur(() => {
-            this.settingRowFocused.set(false);
-            this.treeFocusedElement = null;
-        }));
-        this._register(this.settingsTree.onDidChangeFocus(e => {
-            const element = e.elements[0];
-            if (this.treeFocusedElement === element) {
-                return;
-            }
-            if (this.treeFocusedElement) {
-                this.treeFocusedElement.tabbable = false;
-            }
-            this.treeFocusedElement = element;
-            if (this.treeFocusedElement) {
-                this.treeFocusedElement.tabbable = true;
-            }
-            this.settingsTree.setSelection(element ? [element] : []);
-        }));
-    }
-    onDidChangeSetting(key, value, type, manualReset, scope) {
-        const parsedQuery = parseQuery(this.searchWidget.getValue());
-        const languageFilter = parsedQuery.languageFilter;
-        if (manualReset || (this.pendingSettingUpdate && this.pendingSettingUpdate.key !== key)) {
-            this.updateChangedSetting(key, value, manualReset, languageFilter, scope);
-        }
-        this.pendingSettingUpdate = { key, value, languageFilter };
-        if (SettingsEditor2_1.shouldSettingUpdateFast(type)) {
-            this.settingFastUpdateDelayer.trigger(() => this.updateChangedSetting(key, value, manualReset, languageFilter, scope));
-        }
-        else {
-            this.settingSlowUpdateDelayer.trigger(() => this.updateChangedSetting(key, value, manualReset, languageFilter, scope));
-        }
-    }
-    updateTreeScrollSync() {
-        this.settingRenderers.cancelSuggesters();
-        if (this.searchResultModel) {
-            return;
-        }
-        if (!this.tocTreeModel) {
-            return;
-        }
-        const elementToSync = this.settingsTree.firstVisibleElement;
-        const element = elementToSync instanceof SettingsTreeSettingElement ? elementToSync.parent :
-            elementToSync instanceof SettingsTreeGroupElement ? elementToSync :
-                null;
-        let nodeExists = true;
-        try {
-            this.tocTree.getNode(element);
-        }
-        catch (e) {
-            nodeExists = false;
-        }
-        if (!nodeExists) {
-            return;
-        }
-        if (element && this.tocTree.getSelection()[0] !== element) {
-            const ancestors = this.getAncestors(element);
-            ancestors.forEach(e => this.tocTree.expand(e));
-            this.tocTree.reveal(element);
-            const elementTop = this.tocTree.getRelativeTop(element);
-            if (typeof elementTop !== 'number') {
-                return;
-            }
-            this.tocTree.collapseAll();
-            ancestors.forEach(e => this.tocTree.expand(e));
-            if (elementTop < 0 || elementTop > 1) {
-                this.tocTree.reveal(element);
-            }
-            else {
-                this.tocTree.reveal(element, elementTop);
-            }
-            this.tocTree.expand(element);
-            this.tocTree.setSelection([element]);
-            const fakeKeyboardEvent = ( new KeyboardEvent('keydown'));
-            fakeKeyboardEvent.fromScroll = true;
-            this.tocTree.setFocus([element], fakeKeyboardEvent);
-        }
-    }
-    getAncestors(element) {
-        const ancestors = [];
-        while (element.parent) {
-            if (element.parent.id !== 'root') {
-                ancestors.push(element.parent);
-            }
-            element = element.parent;
-        }
-        return ancestors.reverse();
-    }
-    updateChangedSetting(key, value, manualReset, languageFilter, scope) {
-        const settingsTarget = this.settingsTargetsWidget.settingsTarget;
-        const resource = URI.isUri(settingsTarget) ? settingsTarget : undefined;
-        const configurationTarget = (resource ? 6  : settingsTarget) ?? 3 ;
-        const overrides = { resource, overrideIdentifiers: languageFilter ? [languageFilter] : undefined };
-        const configurationTargetIsWorkspace = configurationTarget === 5  || configurationTarget === 6 ;
-        const userPassedInManualReset = configurationTargetIsWorkspace || !!languageFilter;
-        const isManualReset = userPassedInManualReset ? manualReset : value === undefined;
-        const inspected = this.configurationService.inspect(key, overrides);
-        if (!userPassedInManualReset && inspected.defaultValue === value) {
-            value = undefined;
-        }
-        return this.configurationService.updateValue(key, value, overrides, configurationTarget, { handleDirtyFile: 'save' })
-            .then(() => {
-            const query = this.searchWidget.getValue();
-            if (query.includes(`@${MODIFIED_SETTING_TAG}`)) {
-                this.refreshTOCTree();
-            }
-            this.renderTree(key, isManualReset);
-            const reportModifiedProps = {
-                key,
-                query,
-                searchResults: this.searchResultModel && this.searchResultModel.getUniqueResults(),
-                rawResults: this.searchResultModel && this.searchResultModel.getRawResults(),
-                showConfiguredOnly: !!this.viewState.tagFilters && ( this.viewState.tagFilters.has(MODIFIED_SETTING_TAG)),
-                isReset: typeof value === 'undefined',
-                settingsTarget: this.settingsTargetsWidget.settingsTarget
-            };
-            return this.reportModifiedSetting(reportModifiedProps);
-        });
-    }
-    reportModifiedSetting(props) {
-        this.pendingSettingUpdate = null;
-        let groupId = undefined;
-        let nlpIndex = undefined;
-        let displayIndex = undefined;
-        if (props.searchResults) {
-            const remoteResult = props.searchResults[1 ];
-            const localResult = props.searchResults[0 ];
-            const localIndex = localResult.filterMatches.findIndex(m => m.setting.key === props.key);
-            groupId = localIndex >= 0 ?
-                'local' :
-                'remote';
-            displayIndex = localIndex >= 0 ?
-                localIndex :
-                remoteResult && (remoteResult.filterMatches.findIndex(m => m.setting.key === props.key) + localResult.filterMatches.length);
-            if (this.searchResultModel) {
-                const rawResults = this.searchResultModel.getRawResults();
-                if (rawResults[1 ]) {
-                    const _nlpIndex = rawResults[1 ].filterMatches.findIndex(m => m.setting.key === props.key);
-                    nlpIndex = _nlpIndex >= 0 ? _nlpIndex : undefined;
-                }
-            }
-        }
-        const reportedTarget = props.settingsTarget === 3  ? 'user' :
-            props.settingsTarget === 4  ? 'user_remote' :
-                props.settingsTarget === 5  ? 'workspace' :
-                    'folder';
-        const data = {
-            key: props.key,
-            groupId,
-            nlpIndex,
-            displayIndex,
-            showConfiguredOnly: props.showConfiguredOnly,
-            isReset: props.isReset,
-            target: reportedTarget
-        };
-        this.telemetryService.publicLog2('settingsEditor.settingModified', data);
-    }
-    onSearchModeToggled() {
-        this.rootElement.classList.remove('no-toc-search');
-        if (this.configurationService.getValue('workbench.settings.settingsSearchTocBehavior') === 'hide') {
-            this.rootElement.classList.toggle('no-toc-search', !!this.searchResultModel);
-        }
-    }
-    scheduleRefresh(element, key = '') {
-        if (key && ( this.scheduledRefreshes.has(key))) {
-            return;
-        }
-        if (!key) {
-            dispose(( this.scheduledRefreshes.values()));
-            this.scheduledRefreshes.clear();
-        }
-        const scheduledRefreshTracker = dom.trackFocus(element);
-        this.scheduledRefreshes.set(key, scheduledRefreshTracker);
-        scheduledRefreshTracker.onDidBlur(() => {
-            scheduledRefreshTracker.dispose();
-            this.scheduledRefreshes.delete(key);
-            this.onConfigUpdate(( new Set([key])));
-        });
-    }
-    addOrRemoveManageExtensionSetting(setting, extension, groups) {
-        const matchingGroups = groups.filter(g => {
-            const lowerCaseId = g.extensionInfo?.id.toLowerCase();
-            return (lowerCaseId === setting.stableExtensionId.toLowerCase() ||
-                lowerCaseId === setting.prereleaseExtensionId.toLowerCase());
-        });
-        const extensionId = setting.displayExtensionId;
-        if (!matchingGroups.length) {
-            const newGroup = {
-                sections: [{
-                        settings: [setting],
-                    }],
-                id: extensionId,
-                title: setting.extensionGroupTitle,
-                titleRange: nullRange,
-                range: nullRange,
-                extensionInfo: {
-                    id: extensionId,
-                    displayName: extension?.displayName,
-                }
-            };
-            groups.push(newGroup);
-            return newGroup;
-        }
-        else if (matchingGroups.length >= 2) {
-            const matchingGroupIndex = matchingGroups.findIndex(group => group.sections.length === 1 && group.sections[0].settings.length === 1 && group.sections[0].settings[0].displayExtensionId);
-            if (matchingGroupIndex !== -1) {
-                groups.splice(matchingGroupIndex, 1);
-            }
-        }
-        return undefined;
-    }
-    async onConfigUpdate(keys, forceRefresh = false, schemaChange = false) {
-        if (keys && this.settingsTreeModel) {
-            return this.updateElementsByKey(keys);
-        }
-        if (!this.defaultSettingsEditorModel) {
-            return;
-        }
-        const groups = this.defaultSettingsEditorModel.settingsGroups.slice(1);
-        const coreSettings = groups.filter(g => !g.extensionInfo);
-        const settingsResult = resolveSettingsTree(tocData, coreSettings, this.logService);
-        const resolvedSettingsRoot = settingsResult.tree;
-        if (settingsResult.leftoverSettings.size && !this.hasWarnedMissingSettings) {
-            const settingKeyList = [];
-            settingsResult.leftoverSettings.forEach(s => {
-                settingKeyList.push(s.key);
-            });
-            this.logService.warn(`SettingsEditor2: Settings not included in settingsLayout.ts: ${settingKeyList.join(', ')}`);
-            this.hasWarnedMissingSettings = true;
-        }
-        const additionalGroups = [];
-        const toggleData = await getExperimentalExtensionToggleData(this.workbenchAssignmentService, this.environmentService, this.productService);
-        if (toggleData && groups.filter(g => g.extensionInfo).length) {
-            for (const key in toggleData.settingsEditorRecommendedExtensions) {
-                const extensionId = key;
-                const isStable = this.productService.quality === 'stable';
-                const [extension] = await this.extensionGalleryService.getExtensions([{ id: extensionId, preRelease: !isStable }], CancellationToken.None);
-                if (!extension) {
-                    continue;
-                }
-                let groupTitle;
-                const manifest = await this.extensionGalleryService.getManifest(extension, CancellationToken.None);
-                const contributesConfiguration = manifest?.contributes?.configuration;
-                if (!Array.isArray(contributesConfiguration)) {
-                    groupTitle = contributesConfiguration?.title;
-                }
-                else if (contributesConfiguration.length === 1) {
-                    groupTitle = contributesConfiguration[0].title;
-                }
-                const extensionName = extension?.displayName ?? extension?.name ?? extensionId;
-                const settingKey = `${key}.manageExtension`;
-                const setting = {
-                    range: nullRange,
-                    key: settingKey,
-                    keyRange: nullRange,
-                    value: null,
-                    valueRange: nullRange,
-                    description: [extension?.description || ''],
-                    descriptionIsMarkdown: false,
-                    descriptionRanges: [],
-                    title: extensionName,
-                    scope: 3 ,
-                    type: 'null',
-                    displayExtensionId: extensionId,
-                    prereleaseExtensionId: key,
-                    stableExtensionId: key,
-                    extensionGroupTitle: groupTitle ?? extensionName
-                };
-                const additionalGroup = this.addOrRemoveManageExtensionSetting(setting, extension, groups);
-                if (additionalGroup) {
-                    additionalGroups.push(additionalGroup);
-                }
-            }
-        }
-        resolvedSettingsRoot.children.push(await createTocTreeForExtensionSettings(this.extensionService, groups.filter(g => g.extensionInfo)));
-        const commonlyUsedDataToUse = await getCommonlyUsedData(this.workbenchAssignmentService, this.environmentService, this.productService);
-        const commonlyUsed = resolveSettingsTree(commonlyUsedDataToUse, groups, this.logService);
-        resolvedSettingsRoot.children.unshift(commonlyUsed.tree);
-        if (toggleData) {
-            this.defaultSettingsEditorModel.setAdditionalGroups(additionalGroups);
-        }
-        if (!this.workspaceTrustManagementService.isWorkspaceTrusted() && ((this.viewState.settingsTarget instanceof URI || this.viewState.settingsTarget === 5) )) {
-            const configuredUntrustedWorkspaceSettings = resolveConfiguredUntrustedSettings(groups, this.viewState.settingsTarget, this.viewState.languageFilter, this.configurationService);
-            if (configuredUntrustedWorkspaceSettings.length) {
-                resolvedSettingsRoot.children.unshift({
-                    id: 'workspaceTrust',
-                    label: ( localize('settings require trust', "Workspace Trust")),
-                    settings: configuredUntrustedWorkspaceSettings
-                });
-            }
-        }
-        this.searchResultModel?.updateChildren();
-        if (this.settingsTreeModel) {
-            this.settingsTreeModel.update(resolvedSettingsRoot);
-            if (schemaChange && !!this.searchResultModel) {
-                return await this.onSearchInputChanged();
-            }
-            this.refreshTOCTree();
-            this.renderTree(undefined, forceRefresh);
-        }
-        else {
-            this.settingsTreeModel = this.instantiationService.createInstance(SettingsTreeModel, this.viewState, this.workspaceTrustManagementService.isWorkspaceTrusted());
-            this.settingsTreeModel.update(resolvedSettingsRoot);
-            this.tocTreeModel.settingsTreeRoot = this.settingsTreeModel.root;
-            const cachedState = !this.viewState.query ? this.restoreCachedState() : undefined;
-            if (cachedState?.searchQuery || this.searchWidget.getValue()) {
-                await this.onSearchInputChanged();
-            }
-            else {
-                this.refreshTOCTree();
-                this.refreshTree();
-                this.tocTree.collapseAll();
-            }
-        }
-    }
-    updateElementsByKey(keys) {
-        if (keys.size) {
-            if (this.searchResultModel) {
-                keys.forEach(key => this.searchResultModel.updateElementsByName(key));
-            }
-            if (this.settingsTreeModel) {
-                keys.forEach(key => this.settingsTreeModel.updateElementsByName(key));
-            }
-            this.renderTree();
-        }
-        else {
-            this.renderTree();
-        }
-    }
-    getActiveControlInSettingsTree() {
-        return (document.activeElement && dom.isAncestor(document.activeElement, this.settingsTree.getHTMLElement())) ?
-            document.activeElement :
-            null;
-    }
-    renderTree(key, force = false) {
-        if (!force && key && ( this.scheduledRefreshes.has(key))) {
-            this.updateModifiedLabelForKey(key);
-            return;
-        }
-        if (this.contextViewFocused()) {
-            const element = document.querySelector('.context-view');
-            if (element) {
-                this.scheduleRefresh(element, key);
-            }
-            return;
-        }
-        const activeElement = this.getActiveControlInSettingsTree();
-        const focusedSetting = activeElement && this.settingRenderers.getSettingDOMElementForDOMElement(activeElement);
-        if (focusedSetting && !force) {
-            if (key) {
-                const focusedKey = focusedSetting.getAttribute(AbstractSettingRenderer.SETTING_KEY_ATTR);
-                if (focusedKey === key &&
-                    (focusedSetting.parentElement && !focusedSetting.parentElement.classList.contains('setting-item-list'))) {
-                    this.updateModifiedLabelForKey(key);
-                    this.scheduleRefresh(focusedSetting, key);
-                    return;
-                }
-            }
-            else {
-                this.scheduleRefresh(focusedSetting);
-                return;
-            }
-        }
-        this.renderResultCountMessages();
-        if (key) {
-            const elements = this.currentSettingsModel.getElementsByName(key);
-            if (elements && elements.length) {
-                this.refreshTree();
-            }
-            else {
-                return;
-            }
-        }
-        else {
-            this.refreshTree();
-        }
-        return;
-    }
-    contextViewFocused() {
-        return !!dom.findParentWithClass(document.activeElement, 'context-view');
-    }
-    refreshTree() {
-        if (this.isVisible()) {
-            this.settingsTree.setChildren(null, createGroupIterator(this.currentSettingsModel.root));
-        }
-    }
-    refreshTOCTree() {
-        if (this.isVisible()) {
-            this.tocTreeModel.update();
-            this.tocTree.setChildren(null, createTOCIterator(this.tocTreeModel));
-        }
-    }
-    updateModifiedLabelForKey(key) {
-        const dataElements = this.currentSettingsModel.getElementsByName(key);
-        const isModified = dataElements && dataElements[0] && dataElements[0].isConfigured;
-        const elements = this.settingRenderers.getDOMElementsForSettingKey(this.settingsTree.getHTMLElement(), key);
-        if (elements && elements[0]) {
-            elements[0].classList.toggle('is-configured', !!isModified);
-        }
-    }
-    async onSearchInputChanged() {
-        if (!this.currentSettingsModel) {
-            return;
-        }
-        const query = this.searchWidget.getValue().trim();
-        this.viewState.query = query;
-        this.delayedFilterLogging.cancel();
-        await this.triggerSearch(query.replace(/\u203A/g, ' '));
-        if (query && this.searchResultModel) {
-            this.delayedFilterLogging.trigger(() => this.reportFilteringUsed(this.searchResultModel.getUniqueResults()));
-        }
-    }
-    parseSettingFromJSON(query) {
-        const match = query.match(/"([a-zA-Z.]+)": /);
-        return match && match[1];
-    }
-    triggerSearch(query) {
-        this.viewState.tagFilters = ( new Set());
-        this.viewState.extensionFilters = ( new Set());
-        this.viewState.featureFilters = ( new Set());
-        this.viewState.idFilters = ( new Set());
-        this.viewState.languageFilter = undefined;
-        if (query) {
-            const parsedQuery = parseQuery(query);
-            query = parsedQuery.query;
-            parsedQuery.tags.forEach(tag => this.viewState.tagFilters.add(tag));
-            parsedQuery.extensionFilters.forEach(extensionId => this.viewState.extensionFilters.add(extensionId));
-            parsedQuery.featureFilters.forEach(feature => this.viewState.featureFilters.add(feature));
-            parsedQuery.idFilters.forEach(id => this.viewState.idFilters.add(id));
-            this.viewState.languageFilter = parsedQuery.languageFilter;
-        }
-        this.settingsTargetsWidget.updateLanguageFilterIndicators(this.viewState.languageFilter);
-        if (query && query !== '@') {
-            query = this.parseSettingFromJSON(query) || query;
-            return this.triggerFilterPreferences(query);
-        }
-        else {
-            if (this.viewState.tagFilters.size || this.viewState.extensionFilters.size || this.viewState.featureFilters.size || this.viewState.idFilters.size || this.viewState.languageFilter) {
-                this.searchResultModel = this.createFilterModel();
-            }
-            else {
-                this.searchResultModel = null;
-            }
-            this.localSearchDelayer.cancel();
-            this.remoteSearchThrottle.cancel();
-            if (this.searchInProgress) {
-                this.searchInProgress.cancel();
-                this.searchInProgress.dispose();
-                this.searchInProgress = null;
-            }
-            this.tocTree.setFocus([]);
-            this.viewState.filterToCategory = undefined;
-            this.tocTreeModel.currentSearchModel = this.searchResultModel;
-            this.onSearchModeToggled();
-            if (this.searchResultModel) {
-                this.tocTree.setSelection([]);
-                this.tocTree.expandAll();
-                this.refreshTOCTree();
-                this.renderResultCountMessages();
-                this.refreshTree();
-            }
-            else {
-                this.tocTree.collapseAll();
-                this.refreshTOCTree();
-                this.renderResultCountMessages();
-                this.refreshTree();
-            }
-        }
-        return Promise.resolve();
-    }
-    createFilterModel() {
-        const filterModel = this.instantiationService.createInstance(SearchResultModel, this.viewState, this.workspaceTrustManagementService.isWorkspaceTrusted());
-        const fullResult = {
-            filterMatches: []
-        };
-        for (const g of this.defaultSettingsEditorModel.settingsGroups.slice(1)) {
-            for (const sect of g.sections) {
-                for (const setting of sect.settings) {
-                    fullResult.filterMatches.push({ setting, matches: [], matchType: SettingMatchType.None, score: 0 });
-                }
-            }
-        }
-        filterModel.setResult(0, fullResult);
-        return filterModel;
-    }
-    reportFilteringUsed(results) {
-        const nlpResult = results[1 ];
-        const nlpMetadata = nlpResult?.metadata;
-        const duration = {
-            nlpResult: nlpMetadata?.duration
-        };
-        const counts = {};
-        const filterResult = results[0 ];
-        if (filterResult) {
-            counts['filterResult'] = filterResult.filterMatches.length;
-        }
-        if (nlpResult) {
-            counts['nlpResult'] = nlpResult.filterMatches.length;
-        }
-        const requestCount = nlpMetadata?.requestCount;
-        const data = {
-            'durations.nlpResult': duration.nlpResult,
-            'counts.nlpResult': counts['nlpResult'],
-            'counts.filterResult': counts['filterResult'],
-            requestCount
-        };
-        this.telemetryService.publicLog2('settingsEditor.filter', data);
-    }
-    triggerFilterPreferences(query) {
-        if (this.searchInProgress) {
-            this.searchInProgress.cancel();
-            this.searchInProgress = null;
-        }
-        const searchInProgress = this.searchInProgress = ( new CancellationTokenSource());
-        return this.localSearchDelayer.trigger(async () => {
-            if (searchInProgress && !searchInProgress.token.isCancellationRequested) {
-                const progressRunner = this.editorProgressService.show(true);
-                const result = await this.localFilterPreferences(query);
-                if (result && !result.exactMatch) {
-                    this.remoteSearchThrottle.trigger(async () => {
-                        if (searchInProgress && !searchInProgress.token.isCancellationRequested) {
-                            await this.remoteSearchPreferences(query, this.searchInProgress.token);
-                        }
-                        progressRunner.done();
-                    });
-                }
-                else {
-                    progressRunner.done();
-                }
-            }
-        });
-    }
-    localFilterPreferences(query, token) {
-        const localSearchProvider = this.preferencesSearchService.getLocalSearchProvider(query);
-        return this.filterOrSearchPreferences(query, 0 , localSearchProvider, token);
-    }
-    remoteSearchPreferences(query, token) {
-        const remoteSearchProvider = this.preferencesSearchService.getRemoteSearchProvider(query);
-        const newExtSearchProvider = this.preferencesSearchService.getRemoteSearchProvider(query, true);
-        return Promise.all([
-            this.filterOrSearchPreferences(query, 1 , remoteSearchProvider, token),
-            this.filterOrSearchPreferences(query, 2 , newExtSearchProvider, token)
-        ]).then(() => { });
-    }
-    async filterOrSearchPreferences(query, type, searchProvider, token) {
-        const result = await this._filterOrSearchPreferencesModel(query, this.defaultSettingsEditorModel, searchProvider, token);
-        if (token?.isCancellationRequested) {
-            return null;
-        }
-        if (!this.searchResultModel) {
-            this.searchResultModel = this.instantiationService.createInstance(SearchResultModel, this.viewState, this.workspaceTrustManagementService.isWorkspaceTrusted());
-            this.searchResultModel.setResult(type, result);
-            this.tocTreeModel.currentSearchModel = this.searchResultModel;
-            this.onSearchModeToggled();
-        }
-        else {
-            this.searchResultModel.setResult(type, result);
-            this.tocTreeModel.update();
-        }
-        if (type === 0 ) {
-            this.tocTree.setFocus([]);
-            this.viewState.filterToCategory = undefined;
-            this.tocTree.expandAll();
-        }
-        this.settingsTree.scrollTop = 0;
-        this.refreshTOCTree();
-        this.renderTree(undefined, true);
-        return result;
-    }
-    renderResultCountMessages() {
-        if (!this.currentSettingsModel) {
-            return;
-        }
-        this.clearFilterLinkContainer.style.display = this.viewState.tagFilters && this.viewState.tagFilters.size > 0
-            ? 'initial'
-            : 'none';
-        if (!this.searchResultModel) {
-            if (this.countElement.style.display !== 'none') {
-                this.searchResultLabel = null;
-                this.updateInputAriaLabel();
-                this.countElement.style.display = 'none';
-                this.countElement.innerText = '';
-                this.layout(this.dimension);
-            }
-            this.rootElement.classList.remove('no-results');
-            this.splitView.el.style.visibility = 'visible';
-            return;
-        }
-        else {
-            const count = this.searchResultModel.getUniqueResultsCount();
-            let resultString;
-            switch (count) {
-                case 0:
-                    resultString = ( localize('noResults', "No Settings Found"));
-                    break;
-                case 1:
-                    resultString = ( localize('oneResult', "1 Setting Found"));
-                    break;
-                default: resultString = ( localize('moreThanOneResult', "{0} Settings Found", count));
-            }
-            this.searchResultLabel = resultString;
-            this.updateInputAriaLabel();
-            this.countElement.innerText = resultString;
-            aria.status(resultString);
-            if (this.countElement.style.display !== 'block') {
-                this.countElement.style.display = 'block';
-                this.layout(this.dimension);
-            }
-            this.rootElement.classList.toggle('no-results', count === 0);
-            this.splitView.el.style.visibility = count === 0 ? 'hidden' : 'visible';
-        }
-    }
-    _filterOrSearchPreferencesModel(filter, model, provider, token) {
-        const searchP = provider ? provider.searchModel(model, token) : Promise.resolve(null);
-        return searchP
-            .then(undefined, err => {
-            if (isCancellationError(err)) {
-                return Promise.reject(err);
-            }
-            else {
-                return null;
-            }
-        });
-    }
-    layoutSplitView(dimension) {
-        const listHeight = dimension.height - ((72 + 11 + 14) );
-        this.splitView.el.style.height = `${listHeight}px`;
-        this.splitView.layout(this.bodyContainer.clientWidth, listHeight);
-        const firstViewWasVisible = this.splitView.isViewVisible(0);
-        const firstViewVisible = this.bodyContainer.clientWidth >= SettingsEditor2_1.NARROW_TOTAL_WIDTH;
-        this.splitView.setViewVisible(0, firstViewVisible);
-        if (!firstViewWasVisible && firstViewVisible && this.bodyContainer.clientWidth >= SettingsEditor2_1.EDITOR_MIN_WIDTH + SettingsEditor2_1.TOC_RESET_WIDTH) {
-            this.splitView.resizeView(0, SettingsEditor2_1.TOC_RESET_WIDTH);
-        }
-        this.splitView.style({
-            separatorBorder: firstViewVisible ? this.theme.getColor(settingsSashBorder) : Color.transparent
-        });
-    }
-    saveState() {
-        if (this.isVisible()) {
-            const searchQuery = this.searchWidget.getValue().trim();
-            const target = this.settingsTargetsWidget.settingsTarget;
-            if (this.group && this.input) {
-                this.editorMemento.saveEditorState(this.group, this.input, { searchQuery, target });
-            }
-        }
-        else if (this.group && this.input) {
-            this.editorMemento.clearEditorState(this.input, this.group);
-        }
-        super.saveState();
-    }
-};
-SettingsEditor2 = SettingsEditor2_1 = ( __decorate([
-    ( __param(0, ITelemetryService)),
-    ( __param(1, IWorkbenchConfigurationService)),
-    ( __param(2, ITextResourceConfigurationService)),
-    ( __param(3, IThemeService)),
-    ( __param(4, IPreferencesService)),
-    ( __param(5, IInstantiationService)),
-    ( __param(6, IPreferencesSearchService)),
-    ( __param(7, ILogService)),
-    ( __param(8, IContextKeyService)),
-    ( __param(9, IStorageService)),
-    ( __param(10, IEditorGroupsService)),
-    ( __param(11, IUserDataSyncWorkbenchService)),
-    ( __param(12, IUserDataSyncEnablementService)),
-    ( __param(13, IWorkspaceTrustManagementService)),
-    ( __param(14, IExtensionService)),
-    ( __param(15, ILanguageService)),
-    ( __param(16, IExtensionManagementService)),
-    ( __param(17, IWorkbenchAssignmentService)),
-    ( __param(18, IProductService)),
-    ( __param(19, IEnvironmentService)),
-    ( __param(20, IExtensionGalleryService)),
-    ( __param(21, IEditorProgressService))
-], SettingsEditor2));
-let SyncControls = class SyncControls extends Disposable {
-    constructor(container, commandService, userDataSyncService, userDataSyncEnablementService) {
-        super();
-        this.commandService = commandService;
-        this.userDataSyncService = userDataSyncService;
-        this.userDataSyncEnablementService = userDataSyncEnablementService;
-        this._onDidChangeLastSyncedLabel = this._register(( new Emitter()));
-        this.onDidChangeLastSyncedLabel = this._onDidChangeLastSyncedLabel.event;
-        const headerRightControlsContainer = dom.append(container, $('.settings-right-controls'));
-        const turnOnSyncButtonContainer = dom.append(headerRightControlsContainer, $('.turn-on-sync'));
-        this.turnOnSyncButton = this._register(( new Button(turnOnSyncButtonContainer, { title: true, ...defaultButtonStyles })));
-        this.lastSyncedLabel = dom.append(headerRightControlsContainer, $('.last-synced-label'));
-        dom.hide(this.lastSyncedLabel);
-        this.turnOnSyncButton.enabled = true;
-        this.turnOnSyncButton.label = ( localize('turnOnSyncButton', "Turn on Settings Sync"));
-        dom.hide(this.turnOnSyncButton.element);
-        this._register(this.turnOnSyncButton.onDidClick(async () => {
-            await this.commandService.executeCommand('workbench.userDataSync.actions.turnOn');
-        }));
-        this.updateLastSyncedTime();
-        this._register(this.userDataSyncService.onDidChangeLastSyncTime(() => {
-            this.updateLastSyncedTime();
-        }));
-        const updateLastSyncedTimer = this._register(( new IntervalTimer()));
-        updateLastSyncedTimer.cancelAndSet(() => this.updateLastSyncedTime(), 60 * 1000);
-        this.update();
-        this._register(this.userDataSyncService.onDidChangeStatus(() => {
-            this.update();
-        }));
-        this._register(this.userDataSyncEnablementService.onDidChangeEnablement(() => {
-            this.update();
-        }));
-    }
-    updateLastSyncedTime() {
-        const last = this.userDataSyncService.lastSyncTime;
-        let label;
-        if (typeof last === 'number') {
-            const d = fromNow(last, true, undefined, true);
-            label = ( localize('lastSyncedLabel', "Last synced: {0}", d));
-        }
-        else {
-            label = '';
-        }
-        this.lastSyncedLabel.textContent = label;
-        this._onDidChangeLastSyncedLabel.fire(label);
-    }
-    update() {
-        if (this.userDataSyncService.status === "uninitialized" ) {
-            return;
-        }
-        if (this.userDataSyncEnablementService.isEnabled() || this.userDataSyncService.status !== "idle" ) {
-            dom.show(this.lastSyncedLabel);
-            dom.hide(this.turnOnSyncButton.element);
-        }
-        else {
-            dom.hide(this.lastSyncedLabel);
-            dom.show(this.turnOnSyncButton.element);
-        }
-    }
-};
-SyncControls = ( __decorate([
-    ( __param(1, ICommandService)),
-    ( __param(2, IUserDataSyncService)),
-    ( __param(3, IUserDataSyncEnablementService))
-], SyncControls));
-export { SettingsEditor2, createGroupIterator };