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

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

@@ -0,0 +1,1031 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { coalesce, tail, flatten } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { visit } from '../../../../base/common/json.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { Selection } from 'monaco-editor/esm/vs/editor/common/core/selection.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Extensions, OVERRIDE_PROPERTY_REGEX } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { EditorModel } from '../../../common/editor/editorModel.js';
+import { SettingMatchType } from './preferences.js';
+import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { FOLDER_SCOPES, WORKSPACE_SCOPES } from '../../configuration/common/configuration.js';
+import { createValidator } from './preferencesValidation.js';
+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: ( nls.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(startLine, 1, startLine, 1));
+        const edit = {
+            text: groupContent,
+            forceMoveMarkers: true,
+            range: ( new Range(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(
+                        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(
+                    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 = '// ' + ( nls.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));
+export { DefaultKeybindingsEditorModel, DefaultRawSettingsEditorModel, DefaultSettings, DefaultSettingsEditorModel, Settings2EditorModel, SettingsEditorModel, WorkspaceConfigurationEditorModel, defaultKeybindingsContents, nullRange };