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

package/dist/preferences.js

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