@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.0

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

@@ -0,0 +1,1465 @@
+import { __decorate, __param } from '../../../../../../node_modules/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 { withUndefinedAsNull, withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.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';
+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 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) {
+        super(SettingsEditor2.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.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.SETTING_UPDATE_FAST_DEBOUNCE));
+        this.settingSlowUpdateDelayer = ( new Delayer(SettingsEditor2.SETTING_UPDATE_SLOW_DEBOUNCE));
+        this.searchInputDelayer = ( new Delayer(SettingsEditor2.SEARCH_DEBOUNCE));
+        this.updatedConfigSchemaDelayer = ( new Delayer(SettingsEditor2.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.SUGGESTIONS.includes(`@${LANGUAGE_SETTING_TAG}`)) {
+            SettingsEditor2.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.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();
+    }
+    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 withUndefinedAsNull(cachedState);
+    }
+    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.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.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.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.SUGGESTIONS.filter(tag => !query.includes(tag)).map(tag => tag.endsWith(':') ? tag : tag + ' '));
+                }
+                return [];
+            }
+        }, searchBoxLabel, 'settingseditor:searchinput' + SettingsEditor2.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);
+            });
+        }
+    }
+    switchToApplicationSettingsFile() {
+        const query = parseQuery(this.searchWidget.getValue()).query;
+        return this.openSettingsFile({ query }, true);
+    }
+    switchToSettingsFile() {
+        const query = parseQuery(this.searchWidget.getValue()).query;
+        return this.openSettingsFile({ query });
+    }
+    async openSettingsFile(options, forceOpenApplicationSettings) {
+        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);
+                }
+            }
+            if (forceOpenApplicationSettings) {
+                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.TOC_RESET_WIDTH);
+        this.splitView.addView({
+            onDidChange: Event.None,
+            element: this.tocTreeContainer,
+            minimumSize: SettingsEditor2.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.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.TOC_RESET_WIDTH);
+            this.splitView.resizeView(1, totalSize - SettingsEditor2.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 = withUndefinedAsNull(e.elements?.[0]);
+            if (this.tocFocusedElement === element) {
+                return;
+            }
+            this.tocFocusedElement = element;
+            this.tocTree.setSelection(element ? [element] : []);
+            if (this.searchResultModel) {
+                if (this.viewState.filterToCategory !== element) {
+                    this.viewState.filterToCategory = withNullAsUndefined(element);
+                    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 ??= withUndefinedAsNull(this.settingsTree.firstVisibleElement);
+                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.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 prerelease = toggleData.settingsEditorRecommendedExtensions[key].onSettingsEditorOpen.prerelease;
+                const extensionId = (typeof prerelease === 'string' && this.productService.quality !== 'stable') ? prerelease : key;
+                const [extension] = await this.extensionGalleryService.getExtensions([{ id: extensionId }], 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,
+                    stableExtensionId: key,
+                    prereleaseExtensionId: typeof prerelease === 'string' ? prerelease : 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));
+            }
+            keys.forEach(key => this.renderTree(key));
+        }
+        else {
+            return 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(() => {
+            if (searchInProgress && !searchInProgress.token.isCancellationRequested) {
+                return this.localFilterPreferences(query).then(result => {
+                    if (result && !result.exactMatch) {
+                        this.remoteSearchThrottle.trigger(() => {
+                            return searchInProgress && !searchInProgress.token.isCancellationRequested ?
+                                this.remoteSearchPreferences(query, this.searchInProgress.token) :
+                                Promise.resolve();
+                        });
+                    }
+                });
+            }
+            else {
+                return Promise.resolve();
+            }
+        });
+    }
+    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(() => { });
+    }
+    filterOrSearchPreferences(query, type, searchProvider, token) {
+        return this._filterOrSearchPreferencesModel(query, this.defaultSettingsEditorModel, searchProvider, token).then(result => {
+            if (token && 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.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.NARROW_TOTAL_WIDTH;
+        this.splitView.setViewVisible(0, firstViewVisible);
+        if (!firstViewWasVisible && firstViewVisible && this.bodyContainer.clientWidth >= SettingsEditor2.EDITOR_MIN_WIDTH + SettingsEditor2.TOC_RESET_WIDTH) {
+            this.splitView.resizeView(0, SettingsEditor2.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.ID = 'workbench.editor.settings2';
+SettingsEditor2.NUM_INSTANCES = 0;
+SettingsEditor2.SEARCH_DEBOUNCE = 200;
+SettingsEditor2.SETTING_UPDATE_FAST_DEBOUNCE = 200;
+SettingsEditor2.SETTING_UPDATE_SLOW_DEBOUNCE = 1000;
+SettingsEditor2.CONFIG_SCHEMA_UPDATE_DELAYER = 500;
+SettingsEditor2.TOC_MIN_WIDTH = 100;
+SettingsEditor2.TOC_RESET_WIDTH = 200;
+SettingsEditor2.EDITOR_MIN_WIDTH = 500;
+SettingsEditor2.NARROW_TOTAL_WIDTH = SettingsEditor2.TOC_RESET_WIDTH + SettingsEditor2.EDITOR_MIN_WIDTH;
+SettingsEditor2.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}`
+];
+SettingsEditor2 = ( __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))
+], 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 };