@codingame/monaco-vscode-api 1.76.9 → 1.78.0-next.1

package/dist/preferences.js

@@ -0,0 +1,2532 @@
+import { __decorate, EditorInput, __param, IPreferencesService, EditorModel, IExtensionService, Emitter, FOLDER_SETTINGS_PATH, validateSettingsEditorOptions, SIDE_GROUP, DEFAULT_EDITOR_ASSOCIATION, USE_SPLIT_JSON_SETTING, DEFAULT_SETTINGS_EDITOR_SETTING, TextResourceEditorInput, SideBySideEditorInput, parse$1, getErrorMessage, IEditorService, IEditorGroupsService, ITextFileService, IUserDataProfileService, IUserDataProfilesService, IJSONEditingService, IRemoteAgentService, ITextEditorService, ExtensionIdentifierMap, isEmptyObject, visit, isStringArray, SettingMatchType, Selection$2, Range$2, flatten } from './polyfill.js';
+import { getAllUnboundCommands } from './unboundCommands.js';
+import { Language } from './platform.js';
+import { or, matchesPrefix, matchesWords, matchesContiguousSubString, matchesCamelCase } from 'monaco-editor/esm/vs/base/common/filters.js';
+import { UILabelProvider, AriaLabelProvider, UserSettingsLabelProvider } from 'monaco-editor/esm/vs/base/common/keybindingLabels.js';
+import { isString, isObject, isUndefinedOrNull, withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { ExtensionIdentifier } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
+import { coalesce, distinct, tail } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { ResolvedKeybindingItem } from 'monaco-editor/esm/vs/platform/keybinding/common/resolvedKeybindingItem.js';
+import { MenuRegistry } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { compareIgnoreCase, equalsIgnoreCase } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { OS } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { FOLDER_SCOPES, WORKSPACE_SCOPES } from './configuration2.js';
+import { Color } from 'monaco-editor/esm/vs/base/common/color.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions, OVERRIDE_PROPERTY_REGEX, getDefaultValue } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { getCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import { SuggestController } from 'monaco-editor/esm/vs/editor/contrib/suggest/browser/suggestController.js';
+import { CoreEditingCommands } from 'monaco-editor/esm/vs/editor/browser/coreCommands.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+const KEYBINDING_ENTRY_TEMPLATE_ID = 'keybinding.entry.template';
+const SOURCE_SYSTEM = ( (localize('default', "System")));
+const SOURCE_EXTENSION = ( (localize('extension', "Extension")));
+const SOURCE_USER = ( (localize('user', "User")));
+const wordFilter = or(matchesPrefix, matchesWords, matchesContiguousSubString);
+const SOURCE_REGEX = /@source:\s*(user|default|system|extension)/i;
+const EXTENSION_REGEX = /@ext:\s*((".+")|([^\s]+))/i;
+let KeybindingsEditorModel = class KeybindingsEditorModel extends EditorModel {
+    constructor(os, keybindingsService, extensionService) {
+        super();
+        this.keybindingsService = keybindingsService;
+        this.extensionService = extensionService;
+        this._keybindingItems = [];
+        this._keybindingItemsSortedByPrecedence = [];
+        this.modifierLabels = {
+            ui: UILabelProvider.modifierLabels[os],
+            aria: AriaLabelProvider.modifierLabels[os],
+            user: UserSettingsLabelProvider.modifierLabels[os]
+        };
+    }
+    fetch(searchValue, sortByPrecedence = false) {
+        let keybindingItems = sortByPrecedence ? this._keybindingItemsSortedByPrecedence : this._keybindingItems;
+        const commandIdMatches = /@command:\s*(.+)/i.exec(searchValue);
+        if (commandIdMatches && commandIdMatches[1]) {
+            return (
+                 (keybindingItems.filter(k => k.command === commandIdMatches[1])
+                    .map(
+                    keybindingItem => ({ id: KeybindingsEditorModel.getId(keybindingItem), keybindingItem, templateId: KEYBINDING_ENTRY_TEMPLATE_ID })
+                ))
+            );
+        }
+        if (SOURCE_REGEX.test(searchValue)) {
+            keybindingItems = this.filterBySource(keybindingItems, searchValue);
+            searchValue = searchValue.replace(SOURCE_REGEX, '');
+        }
+        else {
+            const extensionMatches = EXTENSION_REGEX.exec(searchValue);
+            if (extensionMatches && (extensionMatches[2] || extensionMatches[3])) {
+                const extensionId = extensionMatches[2] ? extensionMatches[2].substring(1, extensionMatches[2].length - 1) : extensionMatches[3];
+                keybindingItems = this.filterByExtension(keybindingItems, extensionId);
+                searchValue = searchValue.replace(EXTENSION_REGEX, '');
+            }
+            else {
+                const keybindingMatches = /@keybinding:\s*((\".+\")|(\S+))/i.exec(searchValue);
+                if (keybindingMatches && (keybindingMatches[2] || keybindingMatches[3])) {
+                    searchValue = keybindingMatches[2] || `"${keybindingMatches[3]}"`;
+                }
+            }
+        }
+        searchValue = searchValue.trim();
+        if (!searchValue) {
+            return (
+                 (keybindingItems.map(
+                    keybindingItem => ({ id: KeybindingsEditorModel.getId(keybindingItem), keybindingItem, templateId: KEYBINDING_ENTRY_TEMPLATE_ID })
+                ))
+            );
+        }
+        return this.filterByText(keybindingItems, searchValue);
+    }
+    filterBySource(keybindingItems, searchValue) {
+        if (/@source:\s*default/i.test(searchValue) || /@source:\s*system/i.test(searchValue)) {
+            return keybindingItems.filter(k => k.source === SOURCE_SYSTEM);
+        }
+        if (/@source:\s*user/i.test(searchValue)) {
+            return keybindingItems.filter(k => k.source === SOURCE_USER);
+        }
+        if (/@source:\s*extension/i.test(searchValue)) {
+            return keybindingItems.filter(k => !isString(k.source) || k.source === SOURCE_EXTENSION);
+        }
+        return keybindingItems;
+    }
+    filterByExtension(keybindingItems, extension) {
+        extension = extension.toLowerCase().trim();
+        return keybindingItems.filter(k => !isString(k.source) && (ExtensionIdentifier.equals(k.source.identifier, extension) || k.source.displayName?.toLowerCase() === extension.toLowerCase()));
+    }
+    filterByText(keybindingItems, searchValue) {
+        const quoteAtFirstChar = searchValue.charAt(0) === '"';
+        const quoteAtLastChar = searchValue.charAt(searchValue.length - 1) === '"';
+        const completeMatch = quoteAtFirstChar && quoteAtLastChar;
+        if (quoteAtFirstChar) {
+            searchValue = searchValue.substring(1);
+        }
+        if (quoteAtLastChar) {
+            searchValue = searchValue.substring(0, searchValue.length - 1);
+        }
+        searchValue = searchValue.trim();
+        const result = [];
+        const words = searchValue.split(' ');
+        const keybindingWords = this.splitKeybindingWords(words);
+        for (const keybindingItem of keybindingItems) {
+            const keybindingMatches = ( (new KeybindingItemMatches(
+                this.modifierLabels,
+                keybindingItem,
+                searchValue,
+                words,
+                keybindingWords,
+                completeMatch
+            )));
+            if (keybindingMatches.commandIdMatches
+                || keybindingMatches.commandLabelMatches
+                || keybindingMatches.commandDefaultLabelMatches
+                || keybindingMatches.sourceMatches
+                || keybindingMatches.whenMatches
+                || keybindingMatches.keybindingMatches
+                || keybindingMatches.extensionIdMatches
+                || keybindingMatches.extensionLabelMatches) {
+                result.push({
+                    id: KeybindingsEditorModel.getId(keybindingItem),
+                    templateId: KEYBINDING_ENTRY_TEMPLATE_ID,
+                    commandLabelMatches: keybindingMatches.commandLabelMatches || undefined,
+                    commandDefaultLabelMatches: keybindingMatches.commandDefaultLabelMatches || undefined,
+                    keybindingItem,
+                    keybindingMatches: keybindingMatches.keybindingMatches || undefined,
+                    commandIdMatches: keybindingMatches.commandIdMatches || undefined,
+                    sourceMatches: keybindingMatches.sourceMatches || undefined,
+                    whenMatches: keybindingMatches.whenMatches || undefined,
+                    extensionIdMatches: keybindingMatches.extensionIdMatches || undefined,
+                    extensionLabelMatches: keybindingMatches.extensionLabelMatches || undefined
+                });
+            }
+        }
+        return result;
+    }
+    splitKeybindingWords(wordsSeparatedBySpaces) {
+        const result = [];
+        for (const word of wordsSeparatedBySpaces) {
+            result.push(...coalesce(word.split('+')));
+        }
+        return result;
+    }
+    async resolve(actionLabels = ( (new Map()))) {
+        const extensions = ( (new ExtensionIdentifierMap()));
+        for (const extension of this.extensionService.extensions) {
+            extensions.set(extension.identifier, extension);
+        }
+        this._keybindingItemsSortedByPrecedence = [];
+        const boundCommands = ( (new Map()));
+        for (const keybinding of this.keybindingsService.getKeybindings()) {
+            if (keybinding.command) {
+                this._keybindingItemsSortedByPrecedence.push(KeybindingsEditorModel.toKeybindingEntry(keybinding.command, keybinding, actionLabels, extensions));
+                boundCommands.set(keybinding.command, true);
+            }
+        }
+        const commandsWithDefaultKeybindings = ( (this.keybindingsService.getDefaultKeybindings().map(keybinding => keybinding.command)));
+        for (const command of getAllUnboundCommands(boundCommands)) {
+            const keybindingItem = ( (new ResolvedKeybindingItem(
+                undefined,
+                command,
+                null,
+                undefined,
+                commandsWithDefaultKeybindings.indexOf(command) === -1,
+                null,
+                false
+            )));
+            this._keybindingItemsSortedByPrecedence.push(KeybindingsEditorModel.toKeybindingEntry(command, keybindingItem, actionLabels, extensions));
+        }
+        this._keybindingItemsSortedByPrecedence = distinct(this._keybindingItemsSortedByPrecedence, keybindingItem => KeybindingsEditorModel.getId(keybindingItem));
+        this._keybindingItems = this._keybindingItemsSortedByPrecedence.slice(0).sort((a, b) => KeybindingsEditorModel.compareKeybindingData(a, b));
+        return super.resolve();
+    }
+    static getId(keybindingItem) {
+        return keybindingItem.command + (keybindingItem?.keybinding?.getAriaLabel() ?? '') + keybindingItem.when + (isString(keybindingItem.source) ? keybindingItem.source : keybindingItem.source.identifier.value);
+    }
+    static compareKeybindingData(a, b) {
+        if (a.keybinding && !b.keybinding) {
+            return -1;
+        }
+        if (b.keybinding && !a.keybinding) {
+            return 1;
+        }
+        if (a.commandLabel && !b.commandLabel) {
+            return -1;
+        }
+        if (b.commandLabel && !a.commandLabel) {
+            return 1;
+        }
+        if (a.commandLabel && b.commandLabel) {
+            if (a.commandLabel !== b.commandLabel) {
+                return a.commandLabel.localeCompare(b.commandLabel);
+            }
+        }
+        if (a.command === b.command) {
+            return a.keybindingItem.isDefault ? 1 : -1;
+        }
+        return a.command.localeCompare(b.command);
+    }
+    static toKeybindingEntry(command, keybindingItem, actions, extensions) {
+        const menuCommand = MenuRegistry.getCommand(command);
+        const editorActionLabel = actions.get(command);
+        let source = SOURCE_USER;
+        if (keybindingItem.isDefault) {
+            const extensionId = keybindingItem.extensionId ?? (keybindingItem.resolvedKeybinding ? undefined : menuCommand?.source?.id);
+            source = extensionId ? extensions.get(extensionId) ?? SOURCE_EXTENSION : SOURCE_SYSTEM;
+        }
+        return {
+            keybinding: keybindingItem.resolvedKeybinding,
+            keybindingItem,
+            command,
+            commandLabel: KeybindingsEditorModel.getCommandLabel(menuCommand, editorActionLabel),
+            commandDefaultLabel: KeybindingsEditorModel.getCommandDefaultLabel(menuCommand),
+            when: keybindingItem.when ? keybindingItem.when.serialize() : '',
+            source
+        };
+    }
+    static getCommandDefaultLabel(menuCommand) {
+        if (!Language.isDefaultVariant()) {
+            if (menuCommand && menuCommand.title && menuCommand.title.original) {
+                const category = menuCommand.category ? menuCommand.category.original : undefined;
+                const title = menuCommand.title.original;
+                return category ? ( (localize('cat.title', "{0}: {1}", category, title))) : title;
+            }
+        }
+        return null;
+    }
+    static getCommandLabel(menuCommand, editorActionLabel) {
+        if (menuCommand) {
+            const category = menuCommand.category ? typeof menuCommand.category === 'string' ? menuCommand.category : menuCommand.category.value : undefined;
+            const title = typeof menuCommand.title === 'string' ? menuCommand.title : menuCommand.title.value;
+            return category ? ( (localize('cat.title', "{0}: {1}", category, title))) : title;
+        }
+        if (editorActionLabel) {
+            return editorActionLabel;
+        }
+        return '';
+    }
+};
+KeybindingsEditorModel = ( (__decorate([
+    ( (__param(1, IKeybindingService))),
+    ( (__param(2, IExtensionService)))
+], KeybindingsEditorModel)));
+class KeybindingItemMatches {
+    constructor(modifierLabels, keybindingItem, searchValue, words, keybindingWords, completeMatch) {
+        this.modifierLabels = modifierLabels;
+        this.commandIdMatches = null;
+        this.commandLabelMatches = null;
+        this.commandDefaultLabelMatches = null;
+        this.sourceMatches = null;
+        this.whenMatches = null;
+        this.keybindingMatches = null;
+        this.extensionIdMatches = null;
+        this.extensionLabelMatches = null;
+        if (!completeMatch) {
+            this.commandIdMatches = this.matches(searchValue, keybindingItem.command, or(matchesWords, matchesCamelCase), words);
+            this.commandLabelMatches = keybindingItem.commandLabel ? this.matches(searchValue, keybindingItem.commandLabel, (word, wordToMatchAgainst) => matchesWords(word, keybindingItem.commandLabel, true), words) : null;
+            this.commandDefaultLabelMatches = keybindingItem.commandDefaultLabel ? this.matches(searchValue, keybindingItem.commandDefaultLabel, (word, wordToMatchAgainst) => matchesWords(word, keybindingItem.commandDefaultLabel, true), words) : null;
+            this.whenMatches = keybindingItem.when ? this.matches(null, keybindingItem.when, or(matchesWords, matchesCamelCase), words) : null;
+            if (isString(keybindingItem.source)) {
+                this.sourceMatches = this.matches(searchValue, keybindingItem.source, (word, wordToMatchAgainst) => matchesWords(word, keybindingItem.source, true), words);
+            }
+            else {
+                this.extensionLabelMatches = keybindingItem.source.displayName ? this.matches(searchValue, keybindingItem.source.displayName, (word, wordToMatchAgainst) => matchesWords(word, keybindingItem.commandLabel, true), words) : null;
+            }
+        }
+        this.keybindingMatches = keybindingItem.keybinding ? this.matchesKeybinding(keybindingItem.keybinding, searchValue, keybindingWords, completeMatch) : null;
+    }
+    matches(searchValue, wordToMatchAgainst, wordMatchesFilter, words) {
+        let matches = searchValue ? wordFilter(searchValue, wordToMatchAgainst) : null;
+        if (!matches) {
+            matches = this.matchesWords(words, wordToMatchAgainst, wordMatchesFilter);
+        }
+        if (matches) {
+            matches = this.filterAndSort(matches);
+        }
+        return matches;
+    }
+    matchesWords(words, wordToMatchAgainst, wordMatchesFilter) {
+        let matches = [];
+        for (const word of words) {
+            const wordMatches = wordMatchesFilter(word, wordToMatchAgainst);
+            if (wordMatches) {
+                matches = [...(matches || []), ...wordMatches];
+            }
+            else {
+                matches = null;
+                break;
+            }
+        }
+        return matches;
+    }
+    filterAndSort(matches) {
+        return distinct(matches, (a => a.start + '.' + a.end)).filter(match => !matches.some(m => !(m.start === match.start && m.end === match.end) && (m.start <= match.start && m.end >= match.end))).sort((a, b) => a.start - b.start);
+    }
+    matchesKeybinding(keybinding, searchValue, words, completeMatch) {
+        const [firstPart, chordPart] = keybinding.getChords();
+        const userSettingsLabel = keybinding.getUserSettingsLabel();
+        const ariaLabel = keybinding.getAriaLabel();
+        const label = keybinding.getLabel();
+        if ((userSettingsLabel && compareIgnoreCase(searchValue, userSettingsLabel) === 0)
+            || (ariaLabel && compareIgnoreCase(searchValue, ariaLabel) === 0)
+            || (label && compareIgnoreCase(searchValue, label) === 0)) {
+            return {
+                firstPart: this.createCompleteMatch(firstPart),
+                chordPart: this.createCompleteMatch(chordPart)
+            };
+        }
+        const firstPartMatch = {};
+        let chordPartMatch = {};
+        const matchedWords = [];
+        const firstPartMatchedWords = [];
+        let chordPartMatchedWords = [];
+        let matchFirstPart = true;
+        for (let index = 0; index < words.length; index++) {
+            const word = words[index];
+            let firstPartMatched = false;
+            let chordPartMatched = false;
+            matchFirstPart = matchFirstPart && !firstPartMatch.keyCode;
+            let matchChordPart = !chordPartMatch.keyCode;
+            if (matchFirstPart) {
+                firstPartMatched = this.matchPart(firstPart, firstPartMatch, word, completeMatch);
+                if (firstPartMatch.keyCode) {
+                    for (const cordPartMatchedWordIndex of chordPartMatchedWords) {
+                        if (firstPartMatchedWords.indexOf(cordPartMatchedWordIndex) === -1) {
+                            matchedWords.splice(matchedWords.indexOf(cordPartMatchedWordIndex), 1);
+                        }
+                    }
+                    chordPartMatch = {};
+                    chordPartMatchedWords = [];
+                    matchChordPart = false;
+                }
+            }
+            if (matchChordPart) {
+                chordPartMatched = this.matchPart(chordPart, chordPartMatch, word, completeMatch);
+            }
+            if (firstPartMatched) {
+                firstPartMatchedWords.push(index);
+            }
+            if (chordPartMatched) {
+                chordPartMatchedWords.push(index);
+            }
+            if (firstPartMatched || chordPartMatched) {
+                matchedWords.push(index);
+            }
+            matchFirstPart = matchFirstPart && this.isModifier(word);
+        }
+        if (matchedWords.length !== words.length) {
+            return null;
+        }
+        if (completeMatch) {
+            if (!this.isCompleteMatch(firstPart, firstPartMatch)) {
+                return null;
+            }
+            if (!isEmptyObject(chordPartMatch) && !this.isCompleteMatch(chordPart, chordPartMatch)) {
+                return null;
+            }
+        }
+        return this.hasAnyMatch(firstPartMatch) || this.hasAnyMatch(chordPartMatch) ? { firstPart: firstPartMatch, chordPart: chordPartMatch } : null;
+    }
+    matchPart(chord, match, word, completeMatch) {
+        let matched = false;
+        if (this.matchesMetaModifier(chord, word)) {
+            matched = true;
+            match.metaKey = true;
+        }
+        if (this.matchesCtrlModifier(chord, word)) {
+            matched = true;
+            match.ctrlKey = true;
+        }
+        if (this.matchesShiftModifier(chord, word)) {
+            matched = true;
+            match.shiftKey = true;
+        }
+        if (this.matchesAltModifier(chord, word)) {
+            matched = true;
+            match.altKey = true;
+        }
+        if (this.matchesKeyCode(chord, word, completeMatch)) {
+            match.keyCode = true;
+            matched = true;
+        }
+        return matched;
+    }
+    matchesKeyCode(chord, word, completeMatch) {
+        if (!chord) {
+            return false;
+        }
+        const ariaLabel = chord.keyAriaLabel || '';
+        if (completeMatch || ariaLabel.length === 1 || word.length === 1) {
+            if (compareIgnoreCase(ariaLabel, word) === 0) {
+                return true;
+            }
+        }
+        else {
+            if (matchesContiguousSubString(word, ariaLabel)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    matchesMetaModifier(chord, word) {
+        if (!chord) {
+            return false;
+        }
+        if (!chord.metaKey) {
+            return false;
+        }
+        return this.wordMatchesMetaModifier(word);
+    }
+    matchesCtrlModifier(chord, word) {
+        if (!chord) {
+            return false;
+        }
+        if (!chord.ctrlKey) {
+            return false;
+        }
+        return this.wordMatchesCtrlModifier(word);
+    }
+    matchesShiftModifier(chord, word) {
+        if (!chord) {
+            return false;
+        }
+        if (!chord.shiftKey) {
+            return false;
+        }
+        return this.wordMatchesShiftModifier(word);
+    }
+    matchesAltModifier(chord, word) {
+        if (!chord) {
+            return false;
+        }
+        if (!chord.altKey) {
+            return false;
+        }
+        return this.wordMatchesAltModifier(word);
+    }
+    hasAnyMatch(keybindingMatch) {
+        return !!keybindingMatch.altKey ||
+            !!keybindingMatch.ctrlKey ||
+            !!keybindingMatch.metaKey ||
+            !!keybindingMatch.shiftKey ||
+            !!keybindingMatch.keyCode;
+    }
+    isCompleteMatch(chord, match) {
+        if (!chord) {
+            return true;
+        }
+        if (!match.keyCode) {
+            return false;
+        }
+        if (chord.metaKey && !match.metaKey) {
+            return false;
+        }
+        if (chord.altKey && !match.altKey) {
+            return false;
+        }
+        if (chord.ctrlKey && !match.ctrlKey) {
+            return false;
+        }
+        if (chord.shiftKey && !match.shiftKey) {
+            return false;
+        }
+        return true;
+    }
+    createCompleteMatch(chord) {
+        const match = {};
+        if (chord) {
+            match.keyCode = true;
+            if (chord.metaKey) {
+                match.metaKey = true;
+            }
+            if (chord.altKey) {
+                match.altKey = true;
+            }
+            if (chord.ctrlKey) {
+                match.ctrlKey = true;
+            }
+            if (chord.shiftKey) {
+                match.shiftKey = true;
+            }
+        }
+        return match;
+    }
+    isModifier(word) {
+        if (this.wordMatchesAltModifier(word)) {
+            return true;
+        }
+        if (this.wordMatchesCtrlModifier(word)) {
+            return true;
+        }
+        if (this.wordMatchesMetaModifier(word)) {
+            return true;
+        }
+        if (this.wordMatchesShiftModifier(word)) {
+            return true;
+        }
+        return false;
+    }
+    wordMatchesAltModifier(word) {
+        if (equalsIgnoreCase(this.modifierLabels.ui.altKey, word)) {
+            return true;
+        }
+        if (equalsIgnoreCase(this.modifierLabels.aria.altKey, word)) {
+            return true;
+        }
+        if (equalsIgnoreCase(this.modifierLabels.user.altKey, word)) {
+            return true;
+        }
+        if (equalsIgnoreCase(( (localize('option', "option"))), word)) {
+            return true;
+        }
+        return false;
+    }
+    wordMatchesCtrlModifier(word) {
+        if (equalsIgnoreCase(this.modifierLabels.ui.ctrlKey, word)) {
+            return true;
+        }
+        if (equalsIgnoreCase(this.modifierLabels.aria.ctrlKey, word)) {
+            return true;
+        }
+        if (equalsIgnoreCase(this.modifierLabels.user.ctrlKey, word)) {
+            return true;
+        }
+        return false;
+    }
+    wordMatchesMetaModifier(word) {
+        if (equalsIgnoreCase(this.modifierLabels.ui.metaKey, word)) {
+            return true;
+        }
+        if (equalsIgnoreCase(this.modifierLabels.aria.metaKey, word)) {
+            return true;
+        }
+        if (equalsIgnoreCase(this.modifierLabels.user.metaKey, word)) {
+            return true;
+        }
+        if (equalsIgnoreCase(( (localize('meta', "meta"))), word)) {
+            return true;
+        }
+        return false;
+    }
+    wordMatchesShiftModifier(word) {
+        if (equalsIgnoreCase(this.modifierLabels.ui.shiftKey, word)) {
+            return true;
+        }
+        if (equalsIgnoreCase(this.modifierLabels.aria.shiftKey, word)) {
+            return true;
+        }
+        if (equalsIgnoreCase(this.modifierLabels.user.shiftKey, word)) {
+            return true;
+        }
+        return false;
+    }
+}
+let KeybindingsEditorInput = class KeybindingsEditorInput extends EditorInput {
+    constructor(instantiationService) {
+        super();
+        this.searchOptions = null;
+        this.resource = undefined;
+        this.keybindingsModel = instantiationService.createInstance(KeybindingsEditorModel, OS);
+    }
+    get typeId() {
+        return KeybindingsEditorInput.ID;
+    }
+    getName() {
+        return (
+             (localize('keybindingsInputName', "Keyboard Shortcuts"))
+        );
+    }
+    async resolve() {
+        return this.keybindingsModel;
+    }
+    matches(otherInput) {
+        return otherInput instanceof KeybindingsEditorInput;
+    }
+    dispose() {
+        this.keybindingsModel.dispose();
+        super.dispose();
+    }
+};
+KeybindingsEditorInput.ID = 'workbench.input.keybindings';
+KeybindingsEditorInput = ( (__decorate([
+    ( (__param(0, IInstantiationService)))
+], KeybindingsEditorInput)));
+let SettingsEditor2Input = class SettingsEditor2Input extends EditorInput {
+    constructor(_preferencesService) {
+        super();
+        this.resource = ( (URI.from({
+            scheme: Schemas.vscodeSettings,
+            path: `settingseditor`
+        })));
+        this._settingsModel = _preferencesService.createSettings2EditorModel();
+    }
+    matches(otherInput) {
+        return super.matches(otherInput) || otherInput instanceof SettingsEditor2Input;
+    }
+    get typeId() {
+        return SettingsEditor2Input.ID;
+    }
+    getName() {
+        return (
+             (localize('settingsEditor2InputName', "Settings"))
+        );
+    }
+    async resolve() {
+        return this._settingsModel;
+    }
+    dispose() {
+        this._settingsModel.dispose();
+        super.dispose();
+    }
+};
+SettingsEditor2Input.ID = 'workbench.input.settings2';
+SettingsEditor2Input = ( (__decorate([
+    ( (__param(0, IPreferencesService)))
+], SettingsEditor2Input)));
+function canBeType(propTypes, ...types) {
+    return types.some(t => propTypes.includes(t));
+}
+function isNullOrEmpty(value) {
+    return value === '' || isUndefinedOrNull(value);
+}
+function createValidator(prop) {
+    const type = Array.isArray(prop.type) ? prop.type : [prop.type];
+    const isNullable = canBeType(type, 'null');
+    const isNumeric = (canBeType(type, 'number') || canBeType(type, 'integer')) && (type.length === 1 || type.length === 2 && isNullable);
+    const numericValidations = getNumericValidators(prop);
+    const stringValidations = getStringValidators(prop);
+    const arrayValidator = getArrayValidator(prop);
+    const objectValidator = getObjectValidator(prop);
+    return value => {
+        if (isNullable && isNullOrEmpty(value)) {
+            return '';
+        }
+        const errors = [];
+        if (arrayValidator) {
+            const err = arrayValidator(value);
+            if (err) {
+                errors.push(err);
+            }
+        }
+        if (objectValidator) {
+            const err = objectValidator(value);
+            if (err) {
+                errors.push(err);
+            }
+        }
+        if (prop.type === 'boolean' && value !== true && value !== false) {
+            errors.push(( (localize('validations.booleanIncorrectType', 'Incorrect type. Expected "boolean".'))));
+        }
+        if (isNumeric) {
+            if (isNullOrEmpty(value) || typeof value === 'boolean' || Array.isArray(value) || isNaN(+value)) {
+                errors.push(( (localize('validations.expectedNumeric', "Value must be a number."))));
+            }
+            else {
+                errors.push(...( (numericValidations.filter(validator => !validator.isValid(+value)).map(validator => validator.message))));
+            }
+        }
+        if (prop.type === 'string') {
+            if (prop.enum && !isStringArray(prop.enum)) {
+                errors.push(( (localize(
+                    'validations.stringIncorrectEnumOptions',
+                    'The enum options should be strings, but there is a non-string option. Please file an issue with the extension author.'
+                ))));
+            }
+            else if (!isString(value)) {
+                errors.push(( (localize('validations.stringIncorrectType', 'Incorrect type. Expected "string".'))));
+            }
+            else {
+                errors.push(...( (stringValidations.filter(validator => !validator.isValid(value)).map(validator => validator.message))));
+            }
+        }
+        if (errors.length) {
+            return prop.errorMessage ? [prop.errorMessage, ...errors].join(' ') : errors.join(' ');
+        }
+        return '';
+    };
+}
+function getStringValidators(prop) {
+    const uriRegex = /^(([^:/?#]+?):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;
+    let patternRegex;
+    if (typeof prop.pattern === 'string') {
+        patternRegex = ( (new RegExp(prop.pattern)));
+    }
+    return [
+        {
+            enabled: prop.maxLength !== undefined,
+            isValid: ((value) => value.length <= prop.maxLength),
+            message: ( (localize(
+                'validations.maxLength',
+                "Value must be {0} or fewer characters long.",
+                prop.maxLength
+            )))
+        },
+        {
+            enabled: prop.minLength !== undefined,
+            isValid: ((value) => value.length >= prop.minLength),
+            message: ( (localize(
+                'validations.minLength',
+                "Value must be {0} or more characters long.",
+                prop.minLength
+            )))
+        },
+        {
+            enabled: patternRegex !== undefined,
+            isValid: ((value) => patternRegex.test(value)),
+            message: prop.patternErrorMessage || ( (localize('validations.regex', "Value must match regex `{0}`.", prop.pattern)))
+        },
+        {
+            enabled: prop.format === 'color-hex',
+            isValid: ((value) => Color.Format.CSS.parseHex(value)),
+            message: ( (localize(
+                'validations.colorFormat',
+                "Invalid color format. Use #RGB, #RGBA, #RRGGBB or #RRGGBBAA."
+            )))
+        },
+        {
+            enabled: prop.format === 'uri' || prop.format === 'uri-reference',
+            isValid: ((value) => !!value.length),
+            message: ( (localize('validations.uriEmpty', "URI expected.")))
+        },
+        {
+            enabled: prop.format === 'uri' || prop.format === 'uri-reference',
+            isValid: ((value) => uriRegex.test(value)),
+            message: ( (localize('validations.uriMissing', "URI is expected.")))
+        },
+        {
+            enabled: prop.format === 'uri',
+            isValid: ((value) => {
+                const matches = value.match(uriRegex);
+                return !!(matches && matches[2]);
+            }),
+            message: ( (localize('validations.uriSchemeMissing', "URI with a scheme is expected.")))
+        },
+        {
+            enabled: prop.enum !== undefined,
+            isValid: ((value) => {
+                return prop.enum.includes(value);
+            }),
+            message: ( (localize(
+                'validations.invalidStringEnumValue',
+                "Value is not accepted. Valid values: {0}.",
+                prop.enum ? ( (prop.enum.map(key => `"${key}"`))).join(', ') : '[]'
+            )))
+        }
+    ].filter(validation => validation.enabled);
+}
+function getNumericValidators(prop) {
+    const type = Array.isArray(prop.type) ? prop.type : [prop.type];
+    const isNullable = canBeType(type, 'null');
+    const isIntegral = (canBeType(type, 'integer')) && (type.length === 1 || type.length === 2 && isNullable);
+    const isNumeric = canBeType(type, 'number', 'integer') && (type.length === 1 || type.length === 2 && isNullable);
+    if (!isNumeric) {
+        return [];
+    }
+    let exclusiveMax;
+    let exclusiveMin;
+    if (typeof prop.exclusiveMaximum === 'boolean') {
+        exclusiveMax = prop.exclusiveMaximum ? prop.maximum : undefined;
+    }
+    else {
+        exclusiveMax = prop.exclusiveMaximum;
+    }
+    if (typeof prop.exclusiveMinimum === 'boolean') {
+        exclusiveMin = prop.exclusiveMinimum ? prop.minimum : undefined;
+    }
+    else {
+        exclusiveMin = prop.exclusiveMinimum;
+    }
+    return [
+        {
+            enabled: exclusiveMax !== undefined && (prop.maximum === undefined || exclusiveMax <= prop.maximum),
+            isValid: ((value) => value < exclusiveMax),
+            message: ( (localize(
+                'validations.exclusiveMax',
+                "Value must be strictly less than {0}.",
+                exclusiveMax
+            )))
+        },
+        {
+            enabled: exclusiveMin !== undefined && (prop.minimum === undefined || exclusiveMin >= prop.minimum),
+            isValid: ((value) => value > exclusiveMin),
+            message: ( (localize(
+                'validations.exclusiveMin',
+                "Value must be strictly greater than {0}.",
+                exclusiveMin
+            )))
+        },
+        {
+            enabled: prop.maximum !== undefined && (exclusiveMax === undefined || exclusiveMax > prop.maximum),
+            isValid: ((value) => value <= prop.maximum),
+            message: ( (localize(
+                'validations.max',
+                "Value must be less than or equal to {0}.",
+                prop.maximum
+            )))
+        },
+        {
+            enabled: prop.minimum !== undefined && (exclusiveMin === undefined || exclusiveMin < prop.minimum),
+            isValid: ((value) => value >= prop.minimum),
+            message: ( (localize(
+                'validations.min',
+                "Value must be greater than or equal to {0}.",
+                prop.minimum
+            )))
+        },
+        {
+            enabled: prop.multipleOf !== undefined,
+            isValid: ((value) => value % prop.multipleOf === 0),
+            message: ( (localize(
+                'validations.multipleOf',
+                "Value must be a multiple of {0}.",
+                prop.multipleOf
+            )))
+        },
+        {
+            enabled: isIntegral,
+            isValid: ((value) => value % 1 === 0),
+            message: ( (localize('validations.expectedInteger', "Value must be an integer.")))
+        },
+    ].filter(validation => validation.enabled);
+}
+function getArrayValidator(prop) {
+    if (prop.type === 'array' && prop.items && !Array.isArray(prop.items)) {
+        const propItems = prop.items;
+        if (propItems && !Array.isArray(propItems.type)) {
+            const withQuotes = (s) => `'` + s + `'`;
+            return value => {
+                if (!value) {
+                    return null;
+                }
+                let message = '';
+                if (!Array.isArray(value)) {
+                    message += ( (localize('validations.arrayIncorrectType', 'Incorrect type. Expected an array.')));
+                    message += '\n';
+                    return message;
+                }
+                const arrayValue = value;
+                if (prop.uniqueItems) {
+                    if (( (new Set(arrayValue))).size < arrayValue.length) {
+                        message += ( (localize('validations.stringArrayUniqueItems', 'Array has duplicate items')));
+                        message += '\n';
+                    }
+                }
+                if (prop.minItems && arrayValue.length < prop.minItems) {
+                    message += ( (localize(
+                        'validations.stringArrayMinItem',
+                        'Array must have at least {0} items',
+                        prop.minItems
+                    )));
+                    message += '\n';
+                }
+                if (prop.maxItems && arrayValue.length > prop.maxItems) {
+                    message += ( (localize(
+                        'validations.stringArrayMaxItem',
+                        'Array must have at most {0} items',
+                        prop.maxItems
+                    )));
+                    message += '\n';
+                }
+                if (propItems.type === 'string') {
+                    if (!isStringArray(arrayValue)) {
+                        message += ( (localize(
+                            'validations.stringArrayIncorrectType',
+                            'Incorrect type. Expected a string array.'
+                        )));
+                        message += '\n';
+                        return message;
+                    }
+                    if (typeof propItems.pattern === 'string') {
+                        const patternRegex = ( (new RegExp(propItems.pattern)));
+                        arrayValue.forEach(v => {
+                            if (!patternRegex.test(v)) {
+                                message +=
+                                    propItems.patternErrorMessage ||
+                                        ( (localize(
+                                        'validations.stringArrayItemPattern',
+                                        'Value {0} must match regex {1}.',
+                                        withQuotes(v),
+                                        withQuotes(propItems.pattern)
+                                    )));
+                            }
+                        });
+                    }
+                    const propItemsEnum = propItems.enum;
+                    if (propItemsEnum) {
+                        arrayValue.forEach(v => {
+                            if (propItemsEnum.indexOf(v) === -1) {
+                                message += ( (localize(
+                                    'validations.stringArrayItemEnum',
+                                    'Value {0} is not one of {1}',
+                                    withQuotes(v),
+                                    '[' + ( (propItemsEnum.map(withQuotes))).join(', ') + ']'
+                                )));
+                                message += '\n';
+                            }
+                        });
+                    }
+                }
+                else if (propItems.type === 'integer' || propItems.type === 'number') {
+                    arrayValue.forEach(v => {
+                        const errorMessage = getErrorsForSchema(propItems, v);
+                        if (errorMessage) {
+                            message += `${v}: ${errorMessage}\n`;
+                        }
+                    });
+                }
+                return message;
+            };
+        }
+    }
+    return null;
+}
+function getObjectValidator(prop) {
+    if (prop.type === 'object') {
+        const { properties, patternProperties, additionalProperties } = prop;
+        return value => {
+            if (!value) {
+                return null;
+            }
+            const errors = [];
+            if (!isObject(value)) {
+                errors.push(( (localize('validations.objectIncorrectType', 'Incorrect type. Expected an object.'))));
+            }
+            else {
+                ( (Object.keys(value))).forEach((key) => {
+                    const data = value[key];
+                    if (properties && key in properties) {
+                        const errorMessage = getErrorsForSchema(properties[key], data);
+                        if (errorMessage) {
+                            errors.push(`${key}: ${errorMessage}\n`);
+                        }
+                        return;
+                    }
+                    if (patternProperties) {
+                        for (const pattern in patternProperties) {
+                            if (RegExp(pattern).test(key)) {
+                                const errorMessage = getErrorsForSchema(patternProperties[pattern], data);
+                                if (errorMessage) {
+                                    errors.push(`${key}: ${errorMessage}\n`);
+                                }
+                                return;
+                            }
+                        }
+                    }
+                    if (additionalProperties === false) {
+                        errors.push(( (localize('validations.objectPattern', 'Property {0} is not allowed.\n', key))));
+                    }
+                    else if (typeof additionalProperties === 'object') {
+                        const errorMessage = getErrorsForSchema(additionalProperties, data);
+                        if (errorMessage) {
+                            errors.push(`${key}: ${errorMessage}\n`);
+                        }
+                    }
+                });
+            }
+            if (errors.length) {
+                return prop.errorMessage ? [prop.errorMessage, ...errors].join(' ') : errors.join(' ');
+            }
+            return '';
+        };
+    }
+    return null;
+}
+function getErrorsForSchema(propertySchema, data) {
+    const validator = createValidator(propertySchema);
+    const errorMessage = validator(data);
+    return errorMessage;
+}
+const nullRange = { startLineNumber: -1, startColumn: -1, endLineNumber: -1, endColumn: -1 };
+function isNullRange(range) { return range.startLineNumber === -1 && range.startColumn === -1 && range.endLineNumber === -1 && range.endColumn === -1; }
+class AbstractSettingsModel extends EditorModel {
+    constructor() {
+        super(...arguments);
+        this._currentResultGroups = ( (new Map()));
+    }
+    updateResultGroup(id, resultGroup) {
+        if (resultGroup) {
+            this._currentResultGroups.set(id, resultGroup);
+        }
+        else {
+            this._currentResultGroups.delete(id);
+        }
+        this.removeDuplicateResults();
+        return this.update();
+    }
+    removeDuplicateResults() {
+        const settingKeys = ( (new Set()));
+        [...( (this._currentResultGroups.keys()))]
+            .sort((a, b) => this._currentResultGroups.get(a).order - this._currentResultGroups.get(b).order)
+            .forEach(groupId => {
+            const group = this._currentResultGroups.get(groupId);
+            group.result.filterMatches = group.result.filterMatches.filter(s => !settingKeys.has(s.setting.key));
+            group.result.filterMatches.forEach(s => settingKeys.add(s.setting.key));
+        });
+    }
+    compareTwoNullableNumbers(a, b) {
+        const aOrMax = a ?? Number.MAX_SAFE_INTEGER;
+        const bOrMax = b ?? Number.MAX_SAFE_INTEGER;
+        if (aOrMax < bOrMax) {
+            return -1;
+        }
+        else if (aOrMax > bOrMax) {
+            return 1;
+        }
+        else {
+            return 0;
+        }
+    }
+    filterSettings(filter, groupFilter, settingMatcher) {
+        const allGroups = this.filterGroups;
+        const filterMatches = [];
+        for (const group of allGroups) {
+            const groupMatched = groupFilter(group);
+            for (const section of group.sections) {
+                for (const setting of section.settings) {
+                    const settingMatchResult = settingMatcher(setting, group);
+                    if (groupMatched || settingMatchResult) {
+                        filterMatches.push({
+                            setting,
+                            matches: settingMatchResult && settingMatchResult.matches,
+                            matchType: settingMatchResult?.matchType ?? SettingMatchType.None,
+                            score: settingMatchResult?.score ?? 0
+                        });
+                    }
+                }
+            }
+        }
+        filterMatches.sort((a, b) => {
+            if (a.matchType !== b.matchType) {
+                return b.matchType - a.matchType;
+            }
+            else {
+                if (a.setting.extensionInfo && b.setting.extensionInfo
+                    && a.setting.extensionInfo.id === b.setting.extensionInfo.id) {
+                    if (a.setting.categoryLabel !== b.setting.categoryLabel
+                        && (a.setting.categoryOrder !== undefined || b.setting.categoryOrder !== undefined)
+                        && a.setting.categoryOrder !== b.setting.categoryOrder) {
+                        return this.compareTwoNullableNumbers(a.setting.categoryOrder, b.setting.categoryOrder);
+                    }
+                    else if (a.setting.categoryLabel === b.setting.categoryLabel
+                        && (a.setting.order !== undefined || b.setting.order !== undefined)
+                        && a.setting.order !== b.setting.order) {
+                        return this.compareTwoNullableNumbers(a.setting.order, b.setting.order);
+                    }
+                }
+                return b.score - a.score;
+            }
+        });
+        return filterMatches;
+    }
+    getPreference(key) {
+        for (const group of this.settingsGroups) {
+            for (const section of group.sections) {
+                for (const setting of section.settings) {
+                    if (key === setting.key) {
+                        return setting;
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+    collectMetadata(groups) {
+        const metadata = Object.create(null);
+        let hasMetadata = false;
+        groups.forEach(g => {
+            if (g.result.metadata) {
+                metadata[g.id] = g.result.metadata;
+                hasMetadata = true;
+            }
+        });
+        return hasMetadata ? metadata : null;
+    }
+    get filterGroups() {
+        return this.settingsGroups;
+    }
+}
+class SettingsEditorModel extends AbstractSettingsModel {
+    constructor(reference, _configurationTarget) {
+        super();
+        this._configurationTarget = _configurationTarget;
+        this._onDidChangeGroups = this._register(( (new Emitter())));
+        this.onDidChangeGroups = this._onDidChangeGroups.event;
+        this.settingsModel = reference.object.textEditorModel;
+        this._register(this.onWillDispose(() => reference.dispose()));
+        this._register(this.settingsModel.onDidChangeContent(() => {
+            this._settingsGroups = undefined;
+            this._onDidChangeGroups.fire();
+        }));
+    }
+    get uri() {
+        return this.settingsModel.uri;
+    }
+    get configurationTarget() {
+        return this._configurationTarget;
+    }
+    get settingsGroups() {
+        if (!this._settingsGroups) {
+            this.parse();
+        }
+        return this._settingsGroups;
+    }
+    get content() {
+        return this.settingsModel.getValue();
+    }
+    findValueMatches(filter, setting) {
+        return (
+             (this.settingsModel.findMatches(filter, setting.valueRange, false, false, null, false).map(match => match.range))
+        );
+    }
+    isSettingsProperty(property, previousParents) {
+        return previousParents.length === 0;
+    }
+    parse() {
+        this._settingsGroups = parse(this.settingsModel, (property, previousParents) => this.isSettingsProperty(property, previousParents));
+    }
+    update() {
+        const resultGroups = [...( (this._currentResultGroups.values()))];
+        if (!resultGroups.length) {
+            return undefined;
+        }
+        const filteredSettings = [];
+        const matches = [];
+        resultGroups.forEach(group => {
+            group.result.filterMatches.forEach(filterMatch => {
+                filteredSettings.push(filterMatch.setting);
+                if (filterMatch.matches) {
+                    matches.push(...filterMatch.matches);
+                }
+            });
+        });
+        let filteredGroup;
+        const modelGroup = this.settingsGroups[0];
+        if (modelGroup) {
+            filteredGroup = {
+                id: modelGroup.id,
+                range: modelGroup.range,
+                sections: [{
+                        settings: filteredSettings
+                    }],
+                title: modelGroup.title,
+                titleRange: modelGroup.titleRange,
+                order: modelGroup.order,
+                extensionInfo: modelGroup.extensionInfo
+            };
+        }
+        const metadata = this.collectMetadata(resultGroups);
+        return {
+            allGroups: this.settingsGroups,
+            filteredGroups: filteredGroup ? [filteredGroup] : [],
+            matches,
+            metadata
+        };
+    }
+}
+let Settings2EditorModel = class Settings2EditorModel extends AbstractSettingsModel {
+    constructor(_defaultSettings, configurationService) {
+        super();
+        this._defaultSettings = _defaultSettings;
+        this._onDidChangeGroups = this._register(( (new Emitter())));
+        this.onDidChangeGroups = this._onDidChangeGroups.event;
+        this.dirty = false;
+        this._register(configurationService.onDidChangeConfiguration(e => {
+            if (e.source === 7 ) {
+                this.dirty = true;
+                this._onDidChangeGroups.fire();
+            }
+        }));
+        this._register(( (Registry.as(Extensions.Configuration))).onDidSchemaChange(e => {
+            this.dirty = true;
+            this._onDidChangeGroups.fire();
+        }));
+    }
+    get filterGroups() {
+        return this.settingsGroups.slice(1);
+    }
+    get settingsGroups() {
+        const groups = this._defaultSettings.getSettingsGroups(this.dirty);
+        this.dirty = false;
+        return groups;
+    }
+    findValueMatches(filter, setting) {
+        return [];
+    }
+    update() {
+        throw new Error('Not supported');
+    }
+};
+Settings2EditorModel = ( (__decorate([
+    ( (__param(1, IConfigurationService)))
+], Settings2EditorModel)));
+function parse(model, isSettingsProperty) {
+    const settings = [];
+    let overrideSetting = null;
+    let currentProperty = null;
+    let currentParent = [];
+    const previousParents = [];
+    let settingsPropertyIndex = -1;
+    const range = {
+        startLineNumber: 0,
+        startColumn: 0,
+        endLineNumber: 0,
+        endColumn: 0
+    };
+    function onValue(value, offset, length) {
+        if (Array.isArray(currentParent)) {
+            currentParent.push(value);
+        }
+        else if (currentProperty) {
+            currentParent[currentProperty] = value;
+        }
+        if (previousParents.length === settingsPropertyIndex + 1 || (previousParents.length === settingsPropertyIndex + 2 && overrideSetting !== null)) {
+            const setting = previousParents.length === settingsPropertyIndex + 1 ? settings[settings.length - 1] : overrideSetting.overrides[overrideSetting.overrides.length - 1];
+            if (setting) {
+                const valueStartPosition = model.getPositionAt(offset);
+                const valueEndPosition = model.getPositionAt(offset + length);
+                setting.value = value;
+                setting.valueRange = {
+                    startLineNumber: valueStartPosition.lineNumber,
+                    startColumn: valueStartPosition.column,
+                    endLineNumber: valueEndPosition.lineNumber,
+                    endColumn: valueEndPosition.column
+                };
+                setting.range = Object.assign(setting.range, {
+                    endLineNumber: valueEndPosition.lineNumber,
+                    endColumn: valueEndPosition.column
+                });
+            }
+        }
+    }
+    const visitor = {
+        onObjectBegin: (offset, length) => {
+            if (isSettingsProperty(currentProperty, previousParents)) {
+                settingsPropertyIndex = previousParents.length;
+                const position = model.getPositionAt(offset);
+                range.startLineNumber = position.lineNumber;
+                range.startColumn = position.column;
+            }
+            const object = {};
+            onValue(object, offset, length);
+            currentParent = object;
+            currentProperty = null;
+            previousParents.push(currentParent);
+        },
+        onObjectProperty: (name, offset, length) => {
+            currentProperty = name;
+            if (previousParents.length === settingsPropertyIndex + 1 || (previousParents.length === settingsPropertyIndex + 2 && overrideSetting !== null)) {
+                const settingStartPosition = model.getPositionAt(offset);
+                const setting = {
+                    description: [],
+                    descriptionIsMarkdown: false,
+                    key: name,
+                    keyRange: {
+                        startLineNumber: settingStartPosition.lineNumber,
+                        startColumn: settingStartPosition.column + 1,
+                        endLineNumber: settingStartPosition.lineNumber,
+                        endColumn: settingStartPosition.column + length
+                    },
+                    range: {
+                        startLineNumber: settingStartPosition.lineNumber,
+                        startColumn: settingStartPosition.column,
+                        endLineNumber: 0,
+                        endColumn: 0
+                    },
+                    value: null,
+                    valueRange: nullRange,
+                    descriptionRanges: [],
+                    overrides: [],
+                    overrideOf: withNullAsUndefined(overrideSetting)
+                };
+                if (previousParents.length === settingsPropertyIndex + 1) {
+                    settings.push(setting);
+                    if (OVERRIDE_PROPERTY_REGEX.test(name)) {
+                        overrideSetting = setting;
+                    }
+                }
+                else {
+                    overrideSetting.overrides.push(setting);
+                }
+            }
+        },
+        onObjectEnd: (offset, length) => {
+            currentParent = previousParents.pop();
+            if (settingsPropertyIndex !== -1 && (previousParents.length === settingsPropertyIndex + 1 || (previousParents.length === settingsPropertyIndex + 2 && overrideSetting !== null))) {
+                const setting = previousParents.length === settingsPropertyIndex + 1 ? settings[settings.length - 1] : overrideSetting.overrides[overrideSetting.overrides.length - 1];
+                if (setting) {
+                    const valueEndPosition = model.getPositionAt(offset + length);
+                    setting.valueRange = Object.assign(setting.valueRange, {
+                        endLineNumber: valueEndPosition.lineNumber,
+                        endColumn: valueEndPosition.column
+                    });
+                    setting.range = Object.assign(setting.range, {
+                        endLineNumber: valueEndPosition.lineNumber,
+                        endColumn: valueEndPosition.column
+                    });
+                }
+                if (previousParents.length === settingsPropertyIndex + 1) {
+                    overrideSetting = null;
+                }
+            }
+            if (previousParents.length === settingsPropertyIndex) {
+                const position = model.getPositionAt(offset);
+                range.endLineNumber = position.lineNumber;
+                range.endColumn = position.column;
+                settingsPropertyIndex = -1;
+            }
+        },
+        onArrayBegin: (offset, length) => {
+            const array = [];
+            onValue(array, offset, length);
+            previousParents.push(currentParent);
+            currentParent = array;
+            currentProperty = null;
+        },
+        onArrayEnd: (offset, length) => {
+            currentParent = previousParents.pop();
+            if (previousParents.length === settingsPropertyIndex + 1 || (previousParents.length === settingsPropertyIndex + 2 && overrideSetting !== null)) {
+                const setting = previousParents.length === settingsPropertyIndex + 1 ? settings[settings.length - 1] : overrideSetting.overrides[overrideSetting.overrides.length - 1];
+                if (setting) {
+                    const valueEndPosition = model.getPositionAt(offset + length);
+                    setting.valueRange = Object.assign(setting.valueRange, {
+                        endLineNumber: valueEndPosition.lineNumber,
+                        endColumn: valueEndPosition.column
+                    });
+                    setting.range = Object.assign(setting.range, {
+                        endLineNumber: valueEndPosition.lineNumber,
+                        endColumn: valueEndPosition.column
+                    });
+                }
+            }
+        },
+        onLiteralValue: onValue,
+        onError: (error) => {
+            const setting = settings[settings.length - 1];
+            if (setting && (isNullRange(setting.range) || isNullRange(setting.keyRange) || isNullRange(setting.valueRange))) {
+                settings.pop();
+            }
+        }
+    };
+    if (!model.isDisposed()) {
+        visit(model.getValue(), visitor);
+    }
+    return settings.length > 0 ? [{
+            sections: [
+                {
+                    settings
+                }
+            ],
+            title: '',
+            titleRange: nullRange,
+            range
+        }] : [];
+}
+class WorkspaceConfigurationEditorModel extends SettingsEditorModel {
+    constructor() {
+        super(...arguments);
+        this._configurationGroups = [];
+    }
+    get configurationGroups() {
+        return this._configurationGroups;
+    }
+    parse() {
+        super.parse();
+        this._configurationGroups = parse(this.settingsModel, (property, previousParents) => previousParents.length === 0);
+    }
+    isSettingsProperty(property, previousParents) {
+        return property === 'settings' && previousParents.length === 1;
+    }
+}
+class DefaultSettings extends Disposable {
+    constructor(_mostCommonlyUsedSettingsKeys, target) {
+        super();
+        this._mostCommonlyUsedSettingsKeys = _mostCommonlyUsedSettingsKeys;
+        this.target = target;
+        this._settingsByName = ( (new Map()));
+        this._onDidChange = this._register(( (new Emitter())));
+        this.onDidChange = this._onDidChange.event;
+    }
+    getContent(forceUpdate = false) {
+        if (!this._content || forceUpdate) {
+            this.initialize();
+        }
+        return this._content;
+    }
+    getContentWithoutMostCommonlyUsed(forceUpdate = false) {
+        if (!this._contentWithoutMostCommonlyUsed || forceUpdate) {
+            this.initialize();
+        }
+        return this._contentWithoutMostCommonlyUsed;
+    }
+    getSettingsGroups(forceUpdate = false) {
+        if (!this._allSettingsGroups || forceUpdate) {
+            this.initialize();
+        }
+        return this._allSettingsGroups;
+    }
+    initialize() {
+        this._allSettingsGroups = this.parse();
+        this._content = this.toContent(this._allSettingsGroups, 0);
+        this._contentWithoutMostCommonlyUsed = this.toContent(this._allSettingsGroups, 1);
+    }
+    parse() {
+        const settingsGroups = this.getRegisteredGroups();
+        this.initAllSettingsMap(settingsGroups);
+        const mostCommonlyUsed = this.getMostCommonlyUsedSettings(settingsGroups);
+        return [mostCommonlyUsed, ...settingsGroups];
+    }
+    getRegisteredGroups() {
+        const configurations = ( (Registry.as(Extensions.Configuration))).getConfigurations().slice();
+        const groups = this.removeEmptySettingsGroups(configurations.sort(this.compareConfigurationNodes)
+            .reduce((result, config, index, array) => this.parseConfig(config, result, array), []));
+        return this.sortGroups(groups);
+    }
+    sortGroups(groups) {
+        groups.forEach(group => {
+            group.sections.forEach(section => {
+                section.settings.sort((a, b) => a.key.localeCompare(b.key));
+            });
+        });
+        return groups;
+    }
+    initAllSettingsMap(allSettingsGroups) {
+        this._settingsByName = ( (new Map()));
+        for (const group of allSettingsGroups) {
+            for (const section of group.sections) {
+                for (const setting of section.settings) {
+                    this._settingsByName.set(setting.key, setting);
+                }
+            }
+        }
+    }
+    getMostCommonlyUsedSettings(allSettingsGroups) {
+        const settings = coalesce(( (this._mostCommonlyUsedSettingsKeys.map(key => {
+            const setting = this._settingsByName.get(key);
+            if (setting) {
+                return {
+                    description: setting.description,
+                    key: setting.key,
+                    value: setting.value,
+                    keyRange: nullRange,
+                    range: nullRange,
+                    valueRange: nullRange,
+                    overrides: [],
+                    scope: 4 ,
+                    type: setting.type,
+                    enum: setting.enum,
+                    enumDescriptions: setting.enumDescriptions,
+                    descriptionRanges: []
+                };
+            }
+            return null;
+        }))));
+        return {
+            id: 'mostCommonlyUsed',
+            range: nullRange,
+            title: ( (localize('commonlyUsed', "Commonly Used"))),
+            titleRange: nullRange,
+            sections: [
+                {
+                    settings
+                }
+            ]
+        };
+    }
+    parseConfig(config, result, configurations, settingsGroup, seenSettings) {
+        seenSettings = seenSettings ? seenSettings : {};
+        let title = config.title;
+        if (!title) {
+            const configWithTitleAndSameId = configurations.find(c => (c.id === config.id) && c.title);
+            if (configWithTitleAndSameId) {
+                title = configWithTitleAndSameId.title;
+            }
+        }
+        if (title) {
+            if (!settingsGroup) {
+                settingsGroup = result.find(g => g.title === title && g.extensionInfo?.id === config.extensionInfo?.id);
+                if (!settingsGroup) {
+                    settingsGroup = { sections: [{ settings: [] }], id: config.id || '', title: title || '', titleRange: nullRange, order: config.order, range: nullRange, extensionInfo: config.extensionInfo };
+                    result.push(settingsGroup);
+                }
+            }
+            else {
+                settingsGroup.sections[settingsGroup.sections.length - 1].title = title;
+            }
+        }
+        if (config.properties) {
+            if (!settingsGroup) {
+                settingsGroup = { sections: [{ settings: [] }], id: config.id || '', title: config.id || '', titleRange: nullRange, order: config.order, range: nullRange, extensionInfo: config.extensionInfo };
+                result.push(settingsGroup);
+            }
+            const configurationSettings = [];
+            for (const setting of [...settingsGroup.sections[settingsGroup.sections.length - 1].settings, ...this.parseSettings(config)]) {
+                if (!seenSettings[setting.key]) {
+                    configurationSettings.push(setting);
+                    seenSettings[setting.key] = true;
+                }
+            }
+            if (configurationSettings.length) {
+                settingsGroup.sections[settingsGroup.sections.length - 1].settings = configurationSettings;
+            }
+        }
+        config.allOf?.forEach(c => this.parseConfig(c, result, configurations, settingsGroup, seenSettings));
+        return result;
+    }
+    removeEmptySettingsGroups(settingsGroups) {
+        const result = [];
+        for (const settingsGroup of settingsGroups) {
+            settingsGroup.sections = settingsGroup.sections.filter(section => section.settings.length > 0);
+            if (settingsGroup.sections.length) {
+                result.push(settingsGroup);
+            }
+        }
+        return result;
+    }
+    parseSettings(config) {
+        const result = [];
+        const settingsObject = config.properties;
+        const extensionInfo = config.extensionInfo;
+        const categoryLabel = config.extensionInfo?.id === config.id ? config.title : config.id;
+        const categoryOrder = config.order;
+        for (const key in settingsObject) {
+            const prop = settingsObject[key];
+            if (this.matchesScope(prop)) {
+                const value = prop.default;
+                let description = (prop.markdownDescription || prop.description || '');
+                if (typeof description !== 'string') {
+                    description = '';
+                }
+                const descriptionLines = description.split('\n');
+                const overrides = OVERRIDE_PROPERTY_REGEX.test(key) ? this.parseOverrideSettings(prop.default) : [];
+                let listItemType;
+                if (prop.type === 'array' && prop.items && !Array.isArray(prop.items) && prop.items.type) {
+                    if (prop.items.enum) {
+                        listItemType = 'enum';
+                    }
+                    else if (!Array.isArray(prop.items.type)) {
+                        listItemType = prop.items.type;
+                    }
+                }
+                const objectProperties = prop.type === 'object' ? prop.properties : undefined;
+                const objectPatternProperties = prop.type === 'object' ? prop.patternProperties : undefined;
+                const objectAdditionalProperties = prop.type === 'object' ? prop.additionalProperties : undefined;
+                let enumToUse = prop.enum;
+                let enumDescriptions = prop.markdownEnumDescriptions ?? prop.enumDescriptions;
+                let enumDescriptionsAreMarkdown = !!prop.markdownEnumDescriptions;
+                if (listItemType === 'enum' && !Array.isArray(prop.items)) {
+                    enumToUse = prop.items.enum;
+                    enumDescriptions = prop.items.markdownEnumDescriptions ?? prop.items.enumDescriptions;
+                    enumDescriptionsAreMarkdown = !!prop.items.markdownEnumDescriptions;
+                }
+                let allKeysAreBoolean = false;
+                if (prop.type === 'object' && !prop.additionalProperties && prop.properties && ( (Object.keys(prop.properties))).length) {
+                    allKeysAreBoolean = ( (Object.keys(prop.properties))).every(key => {
+                        return prop.properties[key].type === 'boolean';
+                    });
+                }
+                let isLanguageTagSetting = false;
+                if (OVERRIDE_PROPERTY_REGEX.test(key)) {
+                    isLanguageTagSetting = true;
+                }
+                let defaultValueSource;
+                if (!isLanguageTagSetting) {
+                    const registeredConfigurationProp = prop;
+                    if (registeredConfigurationProp && registeredConfigurationProp.defaultValueSource) {
+                        defaultValueSource = registeredConfigurationProp.defaultValueSource;
+                    }
+                }
+                result.push({
+                    key,
+                    value,
+                    description: descriptionLines,
+                    descriptionIsMarkdown: !!prop.markdownDescription,
+                    range: nullRange,
+                    keyRange: nullRange,
+                    valueRange: nullRange,
+                    descriptionRanges: [],
+                    overrides,
+                    scope: prop.scope,
+                    type: prop.type,
+                    arrayItemType: listItemType,
+                    objectProperties,
+                    objectPatternProperties,
+                    objectAdditionalProperties,
+                    enum: enumToUse,
+                    enumDescriptions: enumDescriptions,
+                    enumDescriptionsAreMarkdown: enumDescriptionsAreMarkdown,
+                    uniqueItems: prop.uniqueItems,
+                    tags: prop.tags,
+                    disallowSyncIgnore: prop.disallowSyncIgnore,
+                    restricted: prop.restricted,
+                    extensionInfo: extensionInfo,
+                    deprecationMessage: prop.markdownDeprecationMessage || prop.deprecationMessage,
+                    deprecationMessageIsMarkdown: !!prop.markdownDeprecationMessage,
+                    validator: createValidator(prop),
+                    enumItemLabels: prop.enumItemLabels,
+                    allKeysAreBoolean,
+                    editPresentation: prop.editPresentation,
+                    order: prop.order,
+                    nonLanguageSpecificDefaultValueSource: defaultValueSource,
+                    isLanguageTagSetting,
+                    categoryLabel,
+                    categoryOrder
+                });
+            }
+        }
+        return result;
+    }
+    parseOverrideSettings(overrideSettings) {
+        return (
+             (( (Object.keys(overrideSettings))).map((key) => ({
+                key,
+                value: overrideSettings[key],
+                description: [],
+                descriptionIsMarkdown: false,
+                range: nullRange,
+                keyRange: nullRange,
+                valueRange: nullRange,
+                descriptionRanges: [],
+                overrides: []
+            })))
+        );
+    }
+    matchesScope(property) {
+        if (!property.scope) {
+            return true;
+        }
+        if (this.target === 6 ) {
+            return FOLDER_SCOPES.indexOf(property.scope) !== -1;
+        }
+        if (this.target === 5 ) {
+            return WORKSPACE_SCOPES.indexOf(property.scope) !== -1;
+        }
+        return true;
+    }
+    compareConfigurationNodes(c1, c2) {
+        if (typeof c1.order !== 'number') {
+            return 1;
+        }
+        if (typeof c2.order !== 'number') {
+            return -1;
+        }
+        if (c1.order === c2.order) {
+            const title1 = c1.title || '';
+            const title2 = c2.title || '';
+            return title1.localeCompare(title2);
+        }
+        return c1.order - c2.order;
+    }
+    toContent(settingsGroups, startIndex) {
+        const builder = ( (new SettingsContentBuilder()));
+        for (let i = startIndex; i < settingsGroups.length; i++) {
+            builder.pushGroup(settingsGroups[i], i === startIndex, i === settingsGroups.length - 1);
+        }
+        return builder.getContent();
+    }
+}
+class DefaultSettingsEditorModel extends AbstractSettingsModel {
+    constructor(_uri, reference, defaultSettings) {
+        super();
+        this._uri = _uri;
+        this.defaultSettings = defaultSettings;
+        this._onDidChangeGroups = this._register(( (new Emitter())));
+        this.onDidChangeGroups = this._onDidChangeGroups.event;
+        this._register(defaultSettings.onDidChange(() => this._onDidChangeGroups.fire()));
+        this._model = reference.object.textEditorModel;
+        this._register(this.onWillDispose(() => reference.dispose()));
+    }
+    get uri() {
+        return this._uri;
+    }
+    get target() {
+        return this.defaultSettings.target;
+    }
+    get settingsGroups() {
+        return this.defaultSettings.getSettingsGroups();
+    }
+    get filterGroups() {
+        return this.settingsGroups.slice(1);
+    }
+    update() {
+        if (this._model.isDisposed()) {
+            return undefined;
+        }
+        const resultGroups = [...( (this._currentResultGroups.values()))]
+            .sort((a, b) => a.order - b.order);
+        const nonEmptyResultGroups = resultGroups.filter(group => group.result.filterMatches.length);
+        const startLine = tail(this.settingsGroups).range.endLineNumber + 2;
+        const { settingsGroups: filteredGroups, matches } = this.writeResultGroups(nonEmptyResultGroups, startLine);
+        const metadata = this.collectMetadata(resultGroups);
+        return resultGroups.length ?
+            {
+                allGroups: this.settingsGroups,
+                filteredGroups,
+                matches,
+                metadata
+            } :
+            undefined;
+    }
+    writeResultGroups(groups, startLine) {
+        const contentBuilderOffset = startLine - 1;
+        const builder = ( (new SettingsContentBuilder(contentBuilderOffset)));
+        const settingsGroups = [];
+        const matches = [];
+        if (groups.length) {
+            builder.pushLine(',');
+            groups.forEach(resultGroup => {
+                const settingsGroup = this.getGroup(resultGroup);
+                settingsGroups.push(settingsGroup);
+                matches.push(...this.writeSettingsGroupToBuilder(builder, settingsGroup, resultGroup.result.filterMatches));
+            });
+        }
+        const groupContent = builder.getContent() + '\n';
+        const groupEndLine = this._model.getLineCount();
+        const cursorPosition = ( (new Selection$2(startLine, 1, startLine, 1)));
+        const edit = {
+            text: groupContent,
+            forceMoveMarkers: true,
+            range: ( (new Range$2(startLine, 1, groupEndLine, 1)))
+        };
+        this._model.pushEditOperations([cursorPosition], [edit], () => [cursorPosition]);
+        const tokenizeTo = Math.min(startLine + 60, this._model.getLineCount());
+        this._model.tokenization.forceTokenization(tokenizeTo);
+        return { matches, settingsGroups };
+    }
+    writeSettingsGroupToBuilder(builder, settingsGroup, filterMatches) {
+        filterMatches = ( (filterMatches
+            .map(filteredMatch => {
+            return {
+                setting: filteredMatch.setting,
+                score: filteredMatch.score,
+                matches: filteredMatch.matches && ( (filteredMatch.matches.map(match => {
+                    return (
+                         (new Range$2(
+                            match.startLineNumber - filteredMatch.setting.range.startLineNumber,
+                            match.startColumn,
+                            match.endLineNumber - filteredMatch.setting.range.startLineNumber,
+                            match.endColumn
+                        ))
+                    );
+                })))
+            };
+        })));
+        builder.pushGroup(settingsGroup);
+        const fixedMatches = flatten(( (( (filterMatches
+            .map(m => m.matches || [])))
+            .map((settingMatches, i) => {
+            const setting = settingsGroup.sections[0].settings[i];
+            return (
+                 (settingMatches.map(range => {
+                    return (
+                         (new Range$2(
+                            range.startLineNumber + setting.range.startLineNumber,
+                            range.startColumn,
+                            range.endLineNumber + setting.range.startLineNumber,
+                            range.endColumn
+                        ))
+                    );
+                }))
+            );
+        }))));
+        return fixedMatches;
+    }
+    copySetting(setting) {
+        return {
+            description: setting.description,
+            scope: setting.scope,
+            type: setting.type,
+            enum: setting.enum,
+            enumDescriptions: setting.enumDescriptions,
+            key: setting.key,
+            value: setting.value,
+            range: setting.range,
+            overrides: [],
+            overrideOf: setting.overrideOf,
+            tags: setting.tags,
+            deprecationMessage: setting.deprecationMessage,
+            keyRange: nullRange,
+            valueRange: nullRange,
+            descriptionIsMarkdown: undefined,
+            descriptionRanges: []
+        };
+    }
+    findValueMatches(filter, setting) {
+        return [];
+    }
+    getPreference(key) {
+        for (const group of this.settingsGroups) {
+            for (const section of group.sections) {
+                for (const setting of section.settings) {
+                    if (setting.key === key) {
+                        return setting;
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+    getGroup(resultGroup) {
+        return {
+            id: resultGroup.id,
+            range: nullRange,
+            title: resultGroup.label,
+            titleRange: nullRange,
+            sections: [
+                {
+                    settings: ( (resultGroup.result.filterMatches.map(m => this.copySetting(m.setting))))
+                }
+            ]
+        };
+    }
+}
+class SettingsContentBuilder {
+    get lineCountWithOffset() {
+        return this._contentByLines.length + this._rangeOffset;
+    }
+    get lastLine() {
+        return this._contentByLines[this._contentByLines.length - 1] || '';
+    }
+    constructor(_rangeOffset = 0) {
+        this._rangeOffset = _rangeOffset;
+        this._contentByLines = [];
+    }
+    pushLine(...lineText) {
+        this._contentByLines.push(...lineText);
+    }
+    pushGroup(settingsGroups, isFirst, isLast) {
+        this._contentByLines.push(isFirst ? '[{' : '{');
+        const lastSetting = this._pushGroup(settingsGroups, '  ');
+        if (lastSetting) {
+            const lineIdx = lastSetting.range.endLineNumber - this._rangeOffset;
+            const content = this._contentByLines[lineIdx - 2];
+            this._contentByLines[lineIdx - 2] = content.substring(0, content.length - 1);
+        }
+        this._contentByLines.push(isLast ? '}]' : '},');
+    }
+    _pushGroup(group, indent) {
+        let lastSetting = null;
+        const groupStart = this.lineCountWithOffset + 1;
+        for (const section of group.sections) {
+            if (section.title) {
+                const sectionTitleStart = this.lineCountWithOffset + 1;
+                this.addDescription([section.title], indent, this._contentByLines);
+                section.titleRange = { startLineNumber: sectionTitleStart, startColumn: 1, endLineNumber: this.lineCountWithOffset, endColumn: this.lastLine.length };
+            }
+            if (section.settings.length) {
+                for (const setting of section.settings) {
+                    this.pushSetting(setting, indent);
+                    lastSetting = setting;
+                }
+            }
+        }
+        group.range = { startLineNumber: groupStart, startColumn: 1, endLineNumber: this.lineCountWithOffset, endColumn: this.lastLine.length };
+        return lastSetting;
+    }
+    getContent() {
+        return this._contentByLines.join('\n');
+    }
+    pushSetting(setting, indent) {
+        const settingStart = this.lineCountWithOffset + 1;
+        this.pushSettingDescription(setting, indent);
+        let preValueContent = indent;
+        const keyString = JSON.stringify(setting.key);
+        preValueContent += keyString;
+        setting.keyRange = { startLineNumber: this.lineCountWithOffset + 1, startColumn: preValueContent.indexOf(setting.key) + 1, endLineNumber: this.lineCountWithOffset + 1, endColumn: setting.key.length };
+        preValueContent += ': ';
+        const valueStart = this.lineCountWithOffset + 1;
+        this.pushValue(setting, preValueContent, indent);
+        setting.valueRange = { startLineNumber: valueStart, startColumn: preValueContent.length + 1, endLineNumber: this.lineCountWithOffset, endColumn: this.lastLine.length + 1 };
+        this._contentByLines[this._contentByLines.length - 1] += ',';
+        this._contentByLines.push('');
+        setting.range = { startLineNumber: settingStart, startColumn: 1, endLineNumber: this.lineCountWithOffset, endColumn: this.lastLine.length };
+    }
+    pushSettingDescription(setting, indent) {
+        const fixSettingLink = (line) => line.replace(/`#(.*)#`/g, (match, settingName) => `\`${settingName}\``);
+        setting.descriptionRanges = [];
+        const descriptionPreValue = indent + '// ';
+        const deprecationMessageLines = setting.deprecationMessage?.split(/\n/g) ?? [];
+        for (let line of [...deprecationMessageLines, ...setting.description]) {
+            line = fixSettingLink(line);
+            this._contentByLines.push(descriptionPreValue + line);
+            setting.descriptionRanges.push({ startLineNumber: this.lineCountWithOffset, startColumn: this.lastLine.indexOf(line) + 1, endLineNumber: this.lineCountWithOffset, endColumn: this.lastLine.length });
+        }
+        if (setting.enumDescriptions && setting.enumDescriptions.some(desc => !!desc)) {
+            setting.enumDescriptions.forEach((desc, i) => {
+                const displayEnum = escapeInvisibleChars(String(setting.enum[i]));
+                const line = desc ?
+                    `${displayEnum}: ${fixSettingLink(desc)}` :
+                    displayEnum;
+                const lines = line.split(/\n/g);
+                lines[0] = ' - ' + lines[0];
+                this._contentByLines.push(...( (lines.map(l => `${indent}// ${l}`))));
+                setting.descriptionRanges.push({ startLineNumber: this.lineCountWithOffset, startColumn: this.lastLine.indexOf(line) + 1, endLineNumber: this.lineCountWithOffset, endColumn: this.lastLine.length });
+            });
+        }
+    }
+    pushValue(setting, preValueConent, indent) {
+        const valueString = JSON.stringify(setting.value, null, indent);
+        if (valueString && (typeof setting.value === 'object')) {
+            if (setting.overrides && setting.overrides.length) {
+                this._contentByLines.push(preValueConent + ' {');
+                for (const subSetting of setting.overrides) {
+                    this.pushSetting(subSetting, indent + indent);
+                    this._contentByLines.pop();
+                }
+                const lastSetting = setting.overrides[setting.overrides.length - 1];
+                const content = this._contentByLines[lastSetting.range.endLineNumber - 2];
+                this._contentByLines[lastSetting.range.endLineNumber - 2] = content.substring(0, content.length - 1);
+                this._contentByLines.push(indent + '}');
+            }
+            else {
+                const mulitLineValue = valueString.split('\n');
+                this._contentByLines.push(preValueConent + mulitLineValue[0]);
+                for (let i = 1; i < mulitLineValue.length; i++) {
+                    this._contentByLines.push(indent + mulitLineValue[i]);
+                }
+            }
+        }
+        else {
+            this._contentByLines.push(preValueConent + valueString);
+        }
+    }
+    addDescription(description, indent, result) {
+        for (const line of description) {
+            result.push(indent + '// ' + line);
+        }
+    }
+}
+class RawSettingsContentBuilder extends SettingsContentBuilder {
+    constructor(indent = '\t') {
+        super(0);
+        this.indent = indent;
+    }
+    pushGroup(settingsGroups) {
+        this._pushGroup(settingsGroups, this.indent);
+    }
+}
+class DefaultRawSettingsEditorModel extends Disposable {
+    constructor(defaultSettings) {
+        super();
+        this.defaultSettings = defaultSettings;
+        this._content = null;
+        this._register(defaultSettings.onDidChange(() => this._content = null));
+    }
+    get content() {
+        if (this._content === null) {
+            const builder = ( (new RawSettingsContentBuilder()));
+            builder.pushLine('{');
+            for (const settingsGroup of this.defaultSettings.getRegisteredGroups()) {
+                builder.pushGroup(settingsGroup);
+            }
+            builder.pushLine('}');
+            this._content = builder.getContent();
+        }
+        return this._content;
+    }
+}
+function escapeInvisibleChars(enumValue) {
+    return enumValue && enumValue
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r');
+}
+function defaultKeybindingsContents(keybindingService) {
+    const defaultsHeader = '// ' + ( (localize(
+        'defaultKeybindingsHeader',
+        "Override key bindings by placing them into your key bindings file."
+    )));
+    return defaultsHeader + '\n' + keybindingService.getDefaultKeybindingsContent();
+}
+let DefaultKeybindingsEditorModel = class DefaultKeybindingsEditorModel {
+    constructor(_uri, keybindingService) {
+        this._uri = _uri;
+        this.keybindingService = keybindingService;
+    }
+    get uri() {
+        return this._uri;
+    }
+    get content() {
+        if (!this._content) {
+            this._content = defaultKeybindingsContents(this.keybindingService);
+        }
+        return this._content;
+    }
+    getPreference() {
+        return null;
+    }
+    dispose() {
+    }
+};
+DefaultKeybindingsEditorModel = ( (__decorate([
+    ( (__param(1, IKeybindingService)))
+], DefaultKeybindingsEditorModel)));
+const emptyEditableSettingsContent = '{\n}';
+let PreferencesService = class PreferencesService extends Disposable {
+    constructor(editorService, editorGroupService, textFileService, configurationService, notificationService, contextService, instantiationService, userDataProfileService, userDataProfilesService, textModelResolverService, keybindingService, modelService, jsonEditingService, languageService, labelService, remoteAgentService, textEditorService) {
+        super();
+        this.editorService = editorService;
+        this.editorGroupService = editorGroupService;
+        this.textFileService = textFileService;
+        this.configurationService = configurationService;
+        this.notificationService = notificationService;
+        this.contextService = contextService;
+        this.instantiationService = instantiationService;
+        this.userDataProfileService = userDataProfileService;
+        this.userDataProfilesService = userDataProfilesService;
+        this.textModelResolverService = textModelResolverService;
+        this.modelService = modelService;
+        this.jsonEditingService = jsonEditingService;
+        this.languageService = languageService;
+        this.labelService = labelService;
+        this.remoteAgentService = remoteAgentService;
+        this.textEditorService = textEditorService;
+        this._onDispose = this._register(( (new Emitter())));
+        this.defaultKeybindingsResource = ( (URI.from(
+            { scheme: Schemas.vscode, authority: 'defaultsettings', path: '/keybindings.json' }
+        )));
+        this.defaultSettingsRawResource = ( (URI.from(
+            { scheme: Schemas.vscode, authority: 'defaultsettings', path: '/defaultSettings.json' }
+        )));
+        this._register(keybindingService.onDidUpdateKeybindings(() => {
+            const model = modelService.getModel(this.defaultKeybindingsResource);
+            if (!model) {
+                return;
+            }
+            modelService.updateModel(model, defaultKeybindingsContents(keybindingService));
+        }));
+    }
+    get userSettingsResource() {
+        return this.userDataProfileService.currentProfile.settingsResource;
+    }
+    get workspaceSettingsResource() {
+        if (this.contextService.getWorkbenchState() === 1 ) {
+            return null;
+        }
+        const workspace = this.contextService.getWorkspace();
+        return workspace.configuration || workspace.folders[0].toResource(FOLDER_SETTINGS_PATH);
+    }
+    get settingsEditor2Input() {
+        return this.instantiationService.createInstance(SettingsEditor2Input);
+    }
+    getFolderSettingsResource(resource) {
+        const folder = this.contextService.getWorkspaceFolder(resource);
+        return folder ? folder.toResource(FOLDER_SETTINGS_PATH) : null;
+    }
+    resolveModel(uri) {
+        if (this.isDefaultSettingsResource(uri)) {
+            const target = this.getConfigurationTargetFromDefaultSettingsResource(uri);
+            const languageSelection = this.languageService.createById('jsonc');
+            const model = this._register(this.modelService.createModel('', languageSelection, uri));
+            let defaultSettings;
+            this.configurationService.onDidChangeConfiguration(e => {
+                if (e.source === 7 ) {
+                    const model = this.modelService.getModel(uri);
+                    if (!model) {
+                        return;
+                    }
+                    defaultSettings = this.getDefaultSettings(target);
+                    this.modelService.updateModel(model, defaultSettings.getContentWithoutMostCommonlyUsed(true));
+                    defaultSettings._onDidChange.fire();
+                }
+            });
+            if (!defaultSettings) {
+                defaultSettings = this.getDefaultSettings(target);
+                this.modelService.updateModel(model, defaultSettings.getContentWithoutMostCommonlyUsed(true));
+            }
+            return model;
+        }
+        if (( (this.defaultSettingsRawResource.toString())) === ( (uri.toString()))) {
+            const defaultRawSettingsEditorModel = this.instantiationService.createInstance(DefaultRawSettingsEditorModel, this.getDefaultSettings(3 ));
+            const languageSelection = this.languageService.createById('jsonc');
+            const model = this._register(this.modelService.createModel(defaultRawSettingsEditorModel.content, languageSelection, uri));
+            return model;
+        }
+        if (( (this.defaultKeybindingsResource.toString())) === ( (uri.toString()))) {
+            const defaultKeybindingsEditorModel = this.instantiationService.createInstance(DefaultKeybindingsEditorModel, uri);
+            const languageSelection = this.languageService.createById('jsonc');
+            const model = this._register(this.modelService.createModel(defaultKeybindingsEditorModel.content, languageSelection, uri));
+            return model;
+        }
+        return null;
+    }
+    async createPreferencesEditorModel(uri) {
+        if (this.isDefaultSettingsResource(uri)) {
+            return this.createDefaultSettingsEditorModel(uri);
+        }
+        if (( (this.userSettingsResource.toString())) === ( (uri.toString())) || ( (this.userDataProfilesService.defaultProfile.settingsResource.toString())) === ( (uri.toString()))) {
+            return this.createEditableSettingsEditorModel(3 , uri);
+        }
+        const workspaceSettingsUri = await this.getEditableSettingsURI(5 );
+        if (workspaceSettingsUri && ( (workspaceSettingsUri.toString())) === ( (uri.toString()))) {
+            return this.createEditableSettingsEditorModel(5 , workspaceSettingsUri);
+        }
+        if (this.contextService.getWorkbenchState() === 3 ) {
+            const settingsUri = await this.getEditableSettingsURI(6 , uri);
+            if (settingsUri && ( (settingsUri.toString())) === ( (uri.toString()))) {
+                return this.createEditableSettingsEditorModel(6 , uri);
+            }
+        }
+        const remoteEnvironment = await this.remoteAgentService.getEnvironment();
+        const remoteSettingsUri = remoteEnvironment ? remoteEnvironment.settingsPath : null;
+        if (remoteSettingsUri && ( (remoteSettingsUri.toString())) === ( (uri.toString()))) {
+            return this.createEditableSettingsEditorModel(4 , uri);
+        }
+        return null;
+    }
+    openRawDefaultSettings() {
+        return this.editorService.openEditor({ resource: this.defaultSettingsRawResource });
+    }
+    openRawUserSettings() {
+        return this.editorService.openEditor({ resource: this.userSettingsResource });
+    }
+    shouldOpenJsonByDefault() {
+        return this.configurationService.getValue('workbench.settings.editor') === 'json';
+    }
+    openSettings(options = {}) {
+        options = {
+            ...options,
+            target: 3 ,
+        };
+        if (options.query) {
+            options.jsonEditor = false;
+        }
+        return this.open(this.userSettingsResource, options);
+    }
+    openLanguageSpecificSettings(languageId, options = {}) {
+        if (this.shouldOpenJsonByDefault()) {
+            options.query = undefined;
+            options.revealSetting = { key: `[${languageId}]`, edit: true };
+        }
+        else {
+            options.query = `@lang:${languageId}${options.query ? ` ${options.query}` : ''}`;
+        }
+        options.target = options.target ?? 3 ;
+        return this.open(this.userSettingsResource, options);
+    }
+    open(settingsResource, options) {
+        options = {
+            ...options,
+            jsonEditor: options.jsonEditor ?? this.shouldOpenJsonByDefault()
+        };
+        return options.jsonEditor ?
+            this.openSettingsJson(settingsResource, options) :
+            this.openSettings2(options);
+    }
+    async openSettings2(options) {
+        const input = this.settingsEditor2Input;
+        options = {
+            ...options,
+            focusSearch: true
+        };
+        await this.editorService.openEditor(input, validateSettingsEditorOptions(options), options.openToSide ? SIDE_GROUP : undefined);
+        return this.editorGroupService.activeGroup.activeEditorPane;
+    }
+    openApplicationSettings(options = {}) {
+        options = {
+            ...options,
+            target: 3 ,
+        };
+        return this.open(this.userDataProfilesService.defaultProfile.settingsResource, options);
+    }
+    openUserSettings(options = {}) {
+        options = {
+            ...options,
+            target: 3 ,
+        };
+        return this.open(this.userSettingsResource, options);
+    }
+    async openRemoteSettings(options = {}) {
+        const environment = await this.remoteAgentService.getEnvironment();
+        if (environment) {
+            options = {
+                ...options,
+                target: 4 ,
+            };
+            this.open(environment.settingsPath, options);
+        }
+        return undefined;
+    }
+    openWorkspaceSettings(options = {}) {
+        if (!this.workspaceSettingsResource) {
+            this.notificationService.info(( (localize(
+                'openFolderFirst',
+                "Open a folder or workspace first to create workspace or folder settings."
+            ))));
+            return Promise.reject(null);
+        }
+        options = {
+            ...options,
+            target: 5
+        };
+        return this.open(this.workspaceSettingsResource, options);
+    }
+    async openFolderSettings(options = {}) {
+        options = {
+            ...options,
+            target: 6
+        };
+        if (!options.folderUri) {
+            throw new Error(`Missing folder URI`);
+        }
+        const folderSettingsUri = await this.getEditableSettingsURI(6 , options.folderUri);
+        if (!folderSettingsUri) {
+            throw new Error(`Invalid folder URI - ${options.folderUri.toString()}`);
+        }
+        return this.open(folderSettingsUri, options);
+    }
+    async openGlobalKeybindingSettings(textual, options) {
+        options = { pinned: true, revealIfOpened: true, ...options };
+        if (textual) {
+            const emptyContents = '// ' + ( (localize(
+                'emptyKeybindingsHeader',
+                "Place your key bindings in this file to override the defaults"
+            ))) + '\n[\n]';
+            const editableKeybindings = this.userDataProfileService.currentProfile.keybindingsResource;
+            const openDefaultKeybindings = !!this.configurationService.getValue('workbench.settings.openDefaultKeybindings');
+            await this.createIfNotExists(editableKeybindings, emptyContents);
+            if (openDefaultKeybindings) {
+                const activeEditorGroup = this.editorGroupService.activeGroup;
+                const sideEditorGroup = this.editorGroupService.addGroup(activeEditorGroup.id, 3 );
+                await Promise.all([
+                    this.editorService.openEditor({ resource: this.defaultKeybindingsResource, options: { pinned: true, preserveFocus: true, revealIfOpened: true, override: DEFAULT_EDITOR_ASSOCIATION.id }, label: ( (localize('defaultKeybindings', "Default Keybindings"))), description: '' }),
+                    this.editorService.openEditor({ resource: editableKeybindings, options }, sideEditorGroup.id)
+                ]);
+            }
+            else {
+                await this.editorService.openEditor({ resource: editableKeybindings, options });
+            }
+        }
+        else {
+            const editor = (await this.editorService.openEditor(this.instantiationService.createInstance(KeybindingsEditorInput), { ...options }));
+            if (options.query) {
+                editor.search(options.query);
+            }
+        }
+    }
+    openDefaultKeybindingsFile() {
+        return this.editorService.openEditor({ resource: this.defaultKeybindingsResource, label: ( (localize('defaultKeybindings', "Default Keybindings"))) });
+    }
+    async openSettingsJson(resource, options) {
+        const group = options?.openToSide ? SIDE_GROUP : undefined;
+        const editor = await this.doOpenSettingsJson(resource, options, group);
+        if (editor && options?.revealSetting) {
+            await this.revealSetting(options.revealSetting.key, !!options.revealSetting.edit, editor, resource);
+        }
+        return editor;
+    }
+    async doOpenSettingsJson(resource, options, group) {
+        const openSplitJSON = !!this.configurationService.getValue(USE_SPLIT_JSON_SETTING);
+        const openDefaultSettings = !!this.configurationService.getValue(DEFAULT_SETTINGS_EDITOR_SETTING);
+        if (openSplitJSON || openDefaultSettings) {
+            return this.doOpenSplitJSON(resource, options, group);
+        }
+        const configurationTarget = options?.target ?? 2 ;
+        const editableSettingsEditorInput = await this.getOrCreateEditableSettingsEditorInput(configurationTarget, resource);
+        options = { ...options, pinned: true };
+        return await this.editorService.openEditor(editableSettingsEditorInput, validateSettingsEditorOptions(options), group);
+    }
+    async doOpenSplitJSON(resource, options = {}, group) {
+        const configurationTarget = options.target ?? 2 ;
+        await this.createSettingsIfNotExists(configurationTarget, resource);
+        const preferencesEditorInput = this.createSplitJsonEditorInput(configurationTarget, resource);
+        options = { ...options, pinned: true };
+        return this.editorService.openEditor(preferencesEditorInput, validateSettingsEditorOptions(options), group);
+    }
+    createSplitJsonEditorInput(configurationTarget, resource) {
+        const editableSettingsEditorInput = this.textEditorService.createTextEditor({ resource });
+        const defaultPreferencesEditorInput = this.instantiationService.createInstance(TextResourceEditorInput, this.getDefaultSettingsResource(configurationTarget), undefined, undefined, undefined, undefined);
+        return this.instantiationService.createInstance(SideBySideEditorInput, editableSettingsEditorInput.getName(), undefined, defaultPreferencesEditorInput, editableSettingsEditorInput);
+    }
+    createSettings2EditorModel() {
+        return this.instantiationService.createInstance(Settings2EditorModel, this.getDefaultSettings(3 ));
+    }
+    getConfigurationTargetFromDefaultSettingsResource(uri) {
+        return this.isDefaultWorkspaceSettingsResource(uri) ?
+            5  :
+            this.isDefaultFolderSettingsResource(uri) ?
+                6  :
+                3 ;
+    }
+    isDefaultSettingsResource(uri) {
+        return this.isDefaultUserSettingsResource(uri) || this.isDefaultWorkspaceSettingsResource(uri) || this.isDefaultFolderSettingsResource(uri);
+    }
+    isDefaultUserSettingsResource(uri) {
+        return uri.authority === 'defaultsettings' && uri.scheme === Schemas.vscode && !!uri.path.match(/\/(\d+\/)?settings\.json$/);
+    }
+    isDefaultWorkspaceSettingsResource(uri) {
+        return uri.authority === 'defaultsettings' && uri.scheme === Schemas.vscode && !!uri.path.match(/\/(\d+\/)?workspaceSettings\.json$/);
+    }
+    isDefaultFolderSettingsResource(uri) {
+        return uri.authority === 'defaultsettings' && uri.scheme === Schemas.vscode && !!uri.path.match(/\/(\d+\/)?resourceSettings\.json$/);
+    }
+    getDefaultSettingsResource(configurationTarget) {
+        switch (configurationTarget) {
+            case 5 :
+                return (
+                     (URI.from(
+                        { scheme: Schemas.vscode, authority: 'defaultsettings', path: `/workspaceSettings.json` }
+                    ))
+                );
+            case 6 :
+                return (
+                     (URI.from(
+                        { scheme: Schemas.vscode, authority: 'defaultsettings', path: `/resourceSettings.json` }
+                    ))
+                );
+        }
+        return (
+             (URI.from(
+                { scheme: Schemas.vscode, authority: 'defaultsettings', path: `/settings.json` }
+            ))
+        );
+    }
+    async getOrCreateEditableSettingsEditorInput(target, resource) {
+        await this.createSettingsIfNotExists(target, resource);
+        return this.textEditorService.createTextEditor({ resource });
+    }
+    async createEditableSettingsEditorModel(configurationTarget, settingsUri) {
+        const workspace = this.contextService.getWorkspace();
+        if (workspace.configuration && ( (workspace.configuration.toString())) === ( (settingsUri.toString()))) {
+            const reference = await this.textModelResolverService.createModelReference(settingsUri);
+            return this.instantiationService.createInstance(WorkspaceConfigurationEditorModel, reference, configurationTarget);
+        }
+        const reference = await this.textModelResolverService.createModelReference(settingsUri);
+        return this.instantiationService.createInstance(SettingsEditorModel, reference, configurationTarget);
+    }
+    async createDefaultSettingsEditorModel(defaultSettingsUri) {
+        const reference = await this.textModelResolverService.createModelReference(defaultSettingsUri);
+        const target = this.getConfigurationTargetFromDefaultSettingsResource(defaultSettingsUri);
+        return this.instantiationService.createInstance(DefaultSettingsEditorModel, defaultSettingsUri, reference, this.getDefaultSettings(target));
+    }
+    getDefaultSettings(target) {
+        if (target === 5 ) {
+            if (!this._defaultWorkspaceSettingsContentModel) {
+                this._defaultWorkspaceSettingsContentModel = ( (new DefaultSettings(this.getMostCommonlyUsedSettings(), target)));
+            }
+            return this._defaultWorkspaceSettingsContentModel;
+        }
+        if (target === 6 ) {
+            if (!this._defaultFolderSettingsContentModel) {
+                this._defaultFolderSettingsContentModel = ( (new DefaultSettings(this.getMostCommonlyUsedSettings(), target)));
+            }
+            return this._defaultFolderSettingsContentModel;
+        }
+        if (!this._defaultUserSettingsContentModel) {
+            this._defaultUserSettingsContentModel = ( (new DefaultSettings(this.getMostCommonlyUsedSettings(), target)));
+        }
+        return this._defaultUserSettingsContentModel;
+    }
+    async getEditableSettingsURI(configurationTarget, resource) {
+        switch (configurationTarget) {
+            case 1 :
+                return this.userDataProfilesService.defaultProfile.settingsResource;
+            case 2 :
+            case 3 :
+                return this.userSettingsResource;
+            case 4 : {
+                const remoteEnvironment = await this.remoteAgentService.getEnvironment();
+                return remoteEnvironment ? remoteEnvironment.settingsPath : null;
+            }
+            case 5 :
+                return this.workspaceSettingsResource;
+            case 6 :
+                if (resource) {
+                    return this.getFolderSettingsResource(resource);
+                }
+        }
+        return null;
+    }
+    async createSettingsIfNotExists(target, resource) {
+        if (this.contextService.getWorkbenchState() === 3  && target === 5 ) {
+            const workspaceConfig = this.contextService.getWorkspace().configuration;
+            if (!workspaceConfig) {
+                return;
+            }
+            const content = await this.textFileService.read(workspaceConfig);
+            if (( (Object.keys(parse$1(content.value)))).indexOf('settings') === -1) {
+                await this.jsonEditingService.write(resource, [{ path: ['settings'], value: {} }], true);
+            }
+            return undefined;
+        }
+        await this.createIfNotExists(resource, emptyEditableSettingsContent);
+    }
+    async createIfNotExists(resource, contents) {
+        try {
+            await this.textFileService.read(resource, { acceptTextOnly: true });
+        }
+        catch (error) {
+            if (error.fileOperationResult === 1 ) {
+                try {
+                    await this.textFileService.write(resource, contents);
+                    return;
+                }
+                catch (error2) {
+                    throw new Error(localize('fail.createSettings', "Unable to create '{0}' ({1}).", this.labelService.getUriLabel(resource, { relative: true }), getErrorMessage(error2)));
+                }
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    getMostCommonlyUsedSettings() {
+        return [
+            'files.autoSave',
+            'editor.fontSize',
+            'editor.fontFamily',
+            'editor.tabSize',
+            'editor.renderWhitespace',
+            'editor.cursorStyle',
+            'editor.multiCursorModifier',
+            'editor.insertSpaces',
+            'editor.wordWrap',
+            'files.exclude',
+            'files.associations',
+            'workbench.editor.enablePreview'
+        ];
+    }
+    async revealSetting(settingKey, edit, editor, settingsResource) {
+        const codeEditor = editor ? getCodeEditor(editor.getControl()) : null;
+        if (!codeEditor) {
+            return;
+        }
+        const settingsModel = await this.createPreferencesEditorModel(settingsResource);
+        if (!settingsModel) {
+            return;
+        }
+        const position = await this.getPositionToReveal(settingKey, edit, settingsModel, codeEditor);
+        if (position) {
+            codeEditor.setPosition(position);
+            codeEditor.revealPositionNearTop(position);
+            codeEditor.focus();
+            if (edit) {
+                SuggestController.get(codeEditor)?.triggerSuggest();
+            }
+        }
+    }
+    async getPositionToReveal(settingKey, edit, settingsModel, codeEditor) {
+        const model = codeEditor.getModel();
+        if (!model) {
+            return null;
+        }
+        const schema = ( (Registry.as(Extensions.Configuration))).getConfigurationProperties()[settingKey];
+        const isOverrideProperty = OVERRIDE_PROPERTY_REGEX.test(settingKey);
+        if (!schema && !isOverrideProperty) {
+            return null;
+        }
+        let position = null;
+        const type = schema?.type ?? 'object' ;
+        let setting = settingsModel.getPreference(settingKey);
+        if (!setting && edit) {
+            let defaultValue = (type === 'object' || type === 'array') ? this.configurationService.inspect(settingKey).defaultValue : getDefaultValue(type);
+            defaultValue = defaultValue === undefined && isOverrideProperty ? {} : defaultValue;
+            if (defaultValue !== undefined) {
+                const key = settingsModel instanceof WorkspaceConfigurationEditorModel ? ['settings', settingKey] : [settingKey];
+                await this.jsonEditingService.write(settingsModel.uri, [{ path: key, value: defaultValue }], false);
+                setting = settingsModel.getPreference(settingKey);
+            }
+        }
+        if (setting) {
+            if (edit) {
+                if (isObject(setting.value) || Array.isArray(setting.value)) {
+                    position = { lineNumber: setting.valueRange.startLineNumber, column: setting.valueRange.startColumn + 1 };
+                    codeEditor.setPosition(position);
+                    await CoreEditingCommands.LineBreakInsert.runEditorCommand(null, codeEditor, null);
+                    position = { lineNumber: position.lineNumber + 1, column: model.getLineMaxColumn(position.lineNumber + 1) };
+                    const firstNonWhiteSpaceColumn = model.getLineFirstNonWhitespaceColumn(position.lineNumber);
+                    if (firstNonWhiteSpaceColumn) {
+                        codeEditor.setPosition({ lineNumber: position.lineNumber, column: firstNonWhiteSpaceColumn });
+                        await CoreEditingCommands.LineBreakInsert.runEditorCommand(null, codeEditor, null);
+                        position = { lineNumber: position.lineNumber, column: model.getLineMaxColumn(position.lineNumber) };
+                    }
+                }
+                else {
+                    position = { lineNumber: setting.valueRange.startLineNumber, column: setting.valueRange.endColumn };
+                }
+            }
+            else {
+                position = { lineNumber: setting.keyRange.startLineNumber, column: setting.keyRange.startColumn };
+            }
+        }
+        return position;
+    }
+    dispose() {
+        this._onDispose.fire();
+        super.dispose();
+    }
+};
+PreferencesService = ( (__decorate([
+    ( (__param(0, IEditorService))),
+    ( (__param(1, IEditorGroupsService))),
+    ( (__param(2, ITextFileService))),
+    ( (__param(3, IConfigurationService))),
+    ( (__param(4, INotificationService))),
+    ( (__param(5, IWorkspaceContextService))),
+    ( (__param(6, IInstantiationService))),
+    ( (__param(7, IUserDataProfileService))),
+    ( (__param(8, IUserDataProfilesService))),
+    ( (__param(9, ITextModelService))),
+    ( (__param(10, IKeybindingService))),
+    ( (__param(11, IModelService))),
+    ( (__param(12, IJSONEditingService))),
+    ( (__param(13, ILanguageService))),
+    ( (__param(14, ILabelService))),
+    ( (__param(15, IRemoteAgentService))),
+    ( (__param(16, ITextEditorService)))
+], PreferencesService)));
+function getServiceOverride() {
+    return {
+        [( IPreferencesService.toString())]: new SyncDescriptor(PreferencesService)
+    };
+}
+export { getServiceOverride as default };