@codingame/monaco-vscode-api 1.67.17 → 1.67.20

package/dist/configuration.js

@@ -1,50 +1,50 @@
-import { E as Emitter, i as isReadableStream, p as peekStream, b as peekReadable, c as bufferToReadable, s as streamToBuffer, d as consumeStream, t as transform, e as isReadableBufferedStream, l as listenStream, f as bufferedStreamToBuffer, r as readableToBuffer, n as newWriteableBufferStream, g as newWriteableStream, u as unsupported } from './missing-services-597951f0.js';
-import { Disposable, toDisposable, dispose, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { getConfigurationValue, addToValueTree, removeFromValueTree, toValuesTree, IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { distinct, equals, coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { deepClone, deepFreeze } from 'monaco-editor/esm/vs/base/common/objects.js';
-import { isObject, isUndefinedOrNull } from 'monaco-editor/esm/vs/base/common/types.js';
-import { OVERRIDE_PROPERTY_REGEX, overrideIdentifiersFromKey, Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { E as Emitter, U as UserSettings, i as isReadableStream, p as peekStream, b as peekReadable, c as bufferToReadable, s as streamToBuffer, d as consumeStream, t as transform, e as isReadableBufferedStream, l as listenStream, f as bufferedStreamToBuffer, r as readableToBuffer, n as newWriteableBufferStream, g as newWriteableStream, u as unsupported } from './missing-services-9c48c894.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { Disposable, toDisposable, dispose, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { extUriBiasedIgnorePathCase, isAbsolutePath, extUri, extUriIgnorePathCase } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { Configuration, DefaultConfigurationModel, ConfigurationModel as ConfigurationModel$1, ConfigurationChangeEvent } from 'monaco-editor/esm/vs/platform/configuration/common/configurationModels.js';
+import { Configuration, DefaultConfigurationModel, ConfigurationModel, ConfigurationChangeEvent } from 'monaco-editor/esm/vs/platform/configuration/common/configurationModels.js';
 import { RunOnceScheduler, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
 import { b as __decorate, c as __param } from './tslib.es6-16b40665.js';
-import { z as ensureFileSystemProviderError, B as createFileSystemProviderError, F as FileSystemProviderErrorCode, D as FileChangesEvent, E as FileOperationError, G as hasOpenReadWriteCloseCapability, H as hasReadWriteCapability, J as hasFileReadStreamCapability, K as toFileSystemProviderErrorCode, t as FileType, u as FilePermission, L as etag, M as FileOperationEvent, O as toFileOperationResult, P as ETAG_DISABLED, Q as hasFileAtomicReadCapability, R as NotModifiedSinceFileOperationError, T as hasFileFolderCopyCapability, C as CancellationTokenSource } from './services-9299c4ca.js';
+import { B as ensureFileSystemProviderError, D as createFileSystemProviderError, F as FileSystemProviderErrorCode, E as FileChangesEvent, G as FileOperationError, H as hasOpenReadWriteCloseCapability, J as hasReadWriteCapability, K as hasFileReadStreamCapability, L as toFileSystemProviderErrorCode, t as FileType, u as FilePermission, M as etag, O as FileOperationEvent, P as toFileOperationResult, Q as ETAG_DISABLED, R as hasFileAtomicReadCapability, T as NotModifiedSinceFileOperationError, U as hasFileFolderCopyCapability, C as CancellationTokenSource } from './services-a8445f52.js';
 import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
 import { canceled } from 'monaco-editor/esm/vs/base/common/errors.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { R as ResourceQueue } from './async-c7fd4178.js';
+import { R as ResourceQueue } from './async-088c7d8b.js';
 import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
 import { TernarySearchTree } from 'monaco-editor/esm/vs/base/common/map.js';
+import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
 import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { P as Position } from './position-291dfe99.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.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 { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
 import 'monaco-editor/esm/vs/base/browser/ui/progressbar/progressbar.js';
+import 'monaco-editor/esm/vs/base/common/objects.js';
 import 'monaco-editor/esm/vs/base/browser/dom.js';
+import 'monaco-editor/esm/vs/base/common/types.js';
 import 'monaco-editor/esm/vs/base/common/color.js';
 import 'monaco-editor/esm/vs/editor/common/services/languageService.js';
 import 'monaco-editor/esm/vs/editor/common/services/languagesRegistry.js';
 import 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
 import 'monaco-editor/esm/vs/editor/common/languages.js';
 import 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import 'monaco-editor/esm/vs/base/common/strings.js';
 import 'monaco-editor/esm/vs/base/parts/quickinput/browser/quickInput.js';
 import 'monaco-editor/esm/vs/platform/instantiation/common/extensions.js';
 import 'monaco-editor/esm/vs/platform/label/common/label.js';
 import 'monaco-editor/esm/vs/editor/editor.api.js';
 import 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import 'monaco-editor/esm/vs/editor/common/languageFeatureRegistry.js';
-import 'monaco-editor/esm/vs/base/common/strings.js';
 import 'monaco-editor/esm/vs/base/browser/event.js';
 import 'monaco-editor/esm/vs/platform/environment/common/environment.js';
 import 'monaco-editor/esm/vs/base/common/platform.js';
@@ -72,920 +72,6 @@ function isConfigurationOverrides(thing) {
         && (!thing.overrideIdentifier || typeof thing.overrideIdentifier === 'string')
         && (!thing.resource || thing.resource instanceof URI);
 }
-var ParseOptions;
- (function(ParseOptions) {
-    ParseOptions.DEFAULT = {
-        allowTrailingComma: true
-    };
-})(ParseOptions || (ParseOptions = {}));
-function createScanner(text, ignoreTrivia = false) {
-    let pos = 0, len = text.length, value = '', tokenOffset = 0, token = 16 , scanError = 0 ;
-    function scanHexDigits(count) {
-        let digits = 0;
-        let hexValue = 0;
-        while (digits < count) {
-            const ch = text.charCodeAt(pos);
-            if (ch >= 48  && ch <= 57 ) {
-                hexValue = hexValue * 16 + ch - 48 ;
-            }
-            else if (ch >= 65  && ch <= 70 ) {
-                hexValue = hexValue * 16 + ch - 65  + 10;
-            }
-            else if (ch >= 97  && ch <= 102 ) {
-                hexValue = hexValue * 16 + ch - 97  + 10;
-            }
-            else {
-                break;
-            }
-            pos++;
-            digits++;
-        }
-        if (digits < count) {
-            hexValue = -1;
-        }
-        return hexValue;
-    }
-    function setPosition(newPosition) {
-        pos = newPosition;
-        value = '';
-        tokenOffset = 0;
-        token = 16 ;
-        scanError = 0 ;
-    }
-    function scanNumber() {
-        const start = pos;
-        if (text.charCodeAt(pos) === 48 ) {
-            pos++;
-        }
-        else {
-            pos++;
-            while (pos < text.length && isDigit(text.charCodeAt(pos))) {
-                pos++;
-            }
-        }
-        if (pos < text.length && text.charCodeAt(pos) === 46 ) {
-            pos++;
-            if (pos < text.length && isDigit(text.charCodeAt(pos))) {
-                pos++;
-                while (pos < text.length && isDigit(text.charCodeAt(pos))) {
-                    pos++;
-                }
-            }
-            else {
-                scanError = 3 ;
-                return text.substring(start, pos);
-            }
-        }
-        let end = pos;
-        if (pos < text.length && ((text.charCodeAt(pos) === 69  || text.charCodeAt(pos) === 101) )) {
-            pos++;
-            if (pos < text.length && text.charCodeAt(pos) === 43  || text.charCodeAt(pos) === 45 ) {
-                pos++;
-            }
-            if (pos < text.length && isDigit(text.charCodeAt(pos))) {
-                pos++;
-                while (pos < text.length && isDigit(text.charCodeAt(pos))) {
-                    pos++;
-                }
-                end = pos;
-            }
-            else {
-                scanError = 3 ;
-            }
-        }
-        return text.substring(start, end);
-    }
-    function scanString() {
-        let result = '', start = pos;
-        while (true) {
-            if (pos >= len) {
-                result += text.substring(start, pos);
-                scanError = 2 ;
-                break;
-            }
-            const ch = text.charCodeAt(pos);
-            if (ch === 34 ) {
-                result += text.substring(start, pos);
-                pos++;
-                break;
-            }
-            if (ch === 92 ) {
-                result += text.substring(start, pos);
-                pos++;
-                if (pos >= len) {
-                    scanError = 2 ;
-                    break;
-                }
-                const ch2 = text.charCodeAt(pos++);
-                switch (ch2) {
-                    case 34 :
-                        result += '\"';
-                        break;
-                    case 92 :
-                        result += '\\';
-                        break;
-                    case 47 :
-                        result += '/';
-                        break;
-                    case 98 :
-                        result += '\b';
-                        break;
-                    case 102 :
-                        result += '\f';
-                        break;
-                    case 110 :
-                        result += '\n';
-                        break;
-                    case 114 :
-                        result += '\r';
-                        break;
-                    case 116 :
-                        result += '\t';
-                        break;
-                    case 117 : {
-                        const ch3 = scanHexDigits(4);
-                        if (ch3 >= 0) {
-                            result += String.fromCharCode(ch3);
-                        }
-                        else {
-                            scanError = 4 ;
-                        }
-                        break;
-                    }
-                    default:
-                        scanError = 5 ;
-                }
-                start = pos;
-                continue;
-            }
-            if (ch >= 0 && ch <= 0x1F) {
-                if (isLineBreak(ch)) {
-                    result += text.substring(start, pos);
-                    scanError = 2 ;
-                    break;
-                }
-                else {
-                    scanError = 6 ;
-                }
-            }
-            pos++;
-        }
-        return result;
-    }
-    function scanNext() {
-        value = '';
-        scanError = 0 ;
-        tokenOffset = pos;
-        if (pos >= len) {
-            tokenOffset = len;
-            return token = 17 ;
-        }
-        let code = text.charCodeAt(pos);
-        if (isWhitespace(code)) {
-            do {
-                pos++;
-                value += String.fromCharCode(code);
-                code = text.charCodeAt(pos);
-            } while (isWhitespace(code));
-            return token = 15 ;
-        }
-        if (isLineBreak(code)) {
-            pos++;
-            value += String.fromCharCode(code);
-            if (code === 13  && text.charCodeAt(pos) === 10 ) {
-                pos++;
-                value += '\n';
-            }
-            return token = 14 ;
-        }
-        switch (code) {
-            case 123 :
-                pos++;
-                return token = 1 ;
-            case 125 :
-                pos++;
-                return token = 2 ;
-            case 91 :
-                pos++;
-                return token = 3 ;
-            case 93 :
-                pos++;
-                return token = 4 ;
-            case 58 :
-                pos++;
-                return token = 6 ;
-            case 44 :
-                pos++;
-                return token = 5 ;
-            case 34 :
-                pos++;
-                value = scanString();
-                return token = 10 ;
-            case 47 : {
-                const start = pos - 1;
-                if (text.charCodeAt(pos + 1) === 47 ) {
-                    pos += 2;
-                    while (pos < len) {
-                        if (isLineBreak(text.charCodeAt(pos))) {
-                            break;
-                        }
-                        pos++;
-                    }
-                    value = text.substring(start, pos);
-                    return token = 12 ;
-                }
-                if (text.charCodeAt(pos + 1) === 42 ) {
-                    pos += 2;
-                    const safeLength = len - 1;
-                    let commentClosed = false;
-                    while (pos < safeLength) {
-                        const ch = text.charCodeAt(pos);
-                        if (ch === 42  && text.charCodeAt(pos + 1) === 47 ) {
-                            pos += 2;
-                            commentClosed = true;
-                            break;
-                        }
-                        pos++;
-                    }
-                    if (!commentClosed) {
-                        pos++;
-                        scanError = 1 ;
-                    }
-                    value = text.substring(start, pos);
-                    return token = 13 ;
-                }
-                value += String.fromCharCode(code);
-                pos++;
-                return token = 16 ;
-            }
-            case 45 :
-                value += String.fromCharCode(code);
-                pos++;
-                if (pos === len || !isDigit(text.charCodeAt(pos))) {
-                    return token = 16 ;
-                }
-            case 48 :
-            case 49 :
-            case 50 :
-            case 51 :
-            case 52 :
-            case 53 :
-            case 54 :
-            case 55 :
-            case 56 :
-            case 57 :
-                value += scanNumber();
-                return token = 11 ;
-            default:
-                while (pos < len && isUnknownContentCharacter(code)) {
-                    pos++;
-                    code = text.charCodeAt(pos);
-                }
-                if (tokenOffset !== pos) {
-                    value = text.substring(tokenOffset, pos);
-                    switch (value) {
-                        case 'true': return token = 8 ;
-                        case 'false': return token = 9 ;
-                        case 'null': return token = 7 ;
-                    }
-                    return token = 16 ;
-                }
-                value += String.fromCharCode(code);
-                pos++;
-                return token = 16 ;
-        }
-    }
-    function isUnknownContentCharacter(code) {
-        if (isWhitespace(code) || isLineBreak(code)) {
-            return false;
-        }
-        switch (code) {
-            case 125 :
-            case 93 :
-            case 123 :
-            case 91 :
-            case 34 :
-            case 58 :
-            case 44 :
-            case 47 :
-                return false;
-        }
-        return true;
-    }
-    function scanNextNonTrivia() {
-        let result;
-        do {
-            result = scanNext();
-        } while (result >= 12  && result <= 15 );
-        return result;
-    }
-    return {
-        setPosition: setPosition,
-        getPosition: () => pos,
-        scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
-        getToken: () => token,
-        getTokenValue: () => value,
-        getTokenOffset: () => tokenOffset,
-        getTokenLength: () => pos - tokenOffset,
-        getTokenError: () => scanError
-    };
-}
-function isWhitespace(ch) {
-    return ch === 32  || ch === 9  || ch === 11  || ch === 12  ||
-        ch === 160  || ch === 5760  || ch >= 8192  && ch <= 8203  ||
-        ch === 8239  || ch === 8287  || ch === 12288  || ch === 65279 ;
-}
-function isLineBreak(ch) {
-    return ch === 10  || ch === 13  || ch === 8232  || ch === 8233 ;
-}
-function isDigit(ch) {
-    return ch >= 48  && ch <= 57 ;
-}
-function visit(text, visitor, options = ParseOptions.DEFAULT) {
-    const _scanner = createScanner(text, false);
-    function toNoArgVisit(visitFunction) {
-        return visitFunction ? () => visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength()) : () => true;
-    }
-    function toOneArgVisit(visitFunction) {
-        return visitFunction ? (arg) => visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength()) : () => true;
-    }
-    const onObjectBegin = toNoArgVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisit(visitor.onObjectProperty), onObjectEnd = toNoArgVisit(visitor.onObjectEnd), onArrayBegin = toNoArgVisit(visitor.onArrayBegin), onArrayEnd = toNoArgVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisit(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
-    const disallowComments = options && options.disallowComments;
-    const allowTrailingComma = options && options.allowTrailingComma;
-    function scanNext() {
-        while (true) {
-            const token = _scanner.scan();
-            switch (_scanner.getTokenError()) {
-                case 4 :
-                    handleError(14 );
-                    break;
-                case 5 :
-                    handleError(15 );
-                    break;
-                case 3 :
-                    handleError(13 );
-                    break;
-                case 1 :
-                    if (!disallowComments) {
-                        handleError(11 );
-                    }
-                    break;
-                case 2 :
-                    handleError(12 );
-                    break;
-                case 6 :
-                    handleError(16 );
-                    break;
-            }
-            switch (token) {
-                case 12 :
-                case 13 :
-                    if (disallowComments) {
-                        handleError(10 );
-                    }
-                    else {
-                        onComment();
-                    }
-                    break;
-                case 16 :
-                    handleError(1 );
-                    break;
-                case 15 :
-                case 14 :
-                    break;
-                default:
-                    return token;
-            }
-        }
-    }
-    function handleError(error, skipUntilAfter = [], skipUntil = []) {
-        onError(error);
-        if (skipUntilAfter.length + skipUntil.length > 0) {
-            let token = _scanner.getToken();
-            while (token !== 17 ) {
-                if (skipUntilAfter.indexOf(token) !== -1) {
-                    scanNext();
-                    break;
-                }
-                else if (skipUntil.indexOf(token) !== -1) {
-                    break;
-                }
-                token = scanNext();
-            }
-        }
-    }
-    function parseString(isValue) {
-        const value = _scanner.getTokenValue();
-        if (isValue) {
-            onLiteralValue(value);
-        }
-        else {
-            onObjectProperty(value);
-        }
-        scanNext();
-        return true;
-    }
-    function parseLiteral() {
-        switch (_scanner.getToken()) {
-            case 11 : {
-                let value = 0;
-                try {
-                    value = JSON.parse(_scanner.getTokenValue());
-                    if (typeof value !== 'number') {
-                        handleError(2 );
-                        value = 0;
-                    }
-                }
-                catch (e) {
-                    handleError(2 );
-                }
-                onLiteralValue(value);
-                break;
-            }
-            case 7 :
-                onLiteralValue(null);
-                break;
-            case 8 :
-                onLiteralValue(true);
-                break;
-            case 9 :
-                onLiteralValue(false);
-                break;
-            default:
-                return false;
-        }
-        scanNext();
-        return true;
-    }
-    function parseProperty() {
-        if (_scanner.getToken() !== 10 ) {
-            handleError(3 , [], [2 , 5 ]);
-            return false;
-        }
-        parseString(false);
-        if (_scanner.getToken() === 6 ) {
-            onSeparator(':');
-            scanNext();
-            if (!parseValue()) {
-                handleError(4 , [], [2 , 5 ]);
-            }
-        }
-        else {
-            handleError(5 , [], [2 , 5 ]);
-        }
-        return true;
-    }
-    function parseObject() {
-        onObjectBegin();
-        scanNext();
-        let needsComma = false;
-        while (_scanner.getToken() !== 2  && _scanner.getToken() !== 17 ) {
-            if (_scanner.getToken() === 5 ) {
-                if (!needsComma) {
-                    handleError(4 , [], []);
-                }
-                onSeparator(',');
-                scanNext();
-                if (_scanner.getToken() === 2  && allowTrailingComma) {
-                    break;
-                }
-            }
-            else if (needsComma) {
-                handleError(6 , [], []);
-            }
-            if (!parseProperty()) {
-                handleError(4 , [], [2 , 5 ]);
-            }
-            needsComma = true;
-        }
-        onObjectEnd();
-        if (_scanner.getToken() !== 2 ) {
-            handleError(7 , [2 ], []);
-        }
-        else {
-            scanNext();
-        }
-        return true;
-    }
-    function parseArray() {
-        onArrayBegin();
-        scanNext();
-        let needsComma = false;
-        while (_scanner.getToken() !== 4  && _scanner.getToken() !== 17 ) {
-            if (_scanner.getToken() === 5 ) {
-                if (!needsComma) {
-                    handleError(4 , [], []);
-                }
-                onSeparator(',');
-                scanNext();
-                if (_scanner.getToken() === 4  && allowTrailingComma) {
-                    break;
-                }
-            }
-            else if (needsComma) {
-                handleError(6 , [], []);
-            }
-            if (!parseValue()) {
-                handleError(4 , [], [4 , 5 ]);
-            }
-            needsComma = true;
-        }
-        onArrayEnd();
-        if (_scanner.getToken() !== 4 ) {
-            handleError(8 , [4 ], []);
-        }
-        else {
-            scanNext();
-        }
-        return true;
-    }
-    function parseValue() {
-        switch (_scanner.getToken()) {
-            case 3 :
-                return parseArray();
-            case 1 :
-                return parseObject();
-            case 10 :
-                return parseString(true);
-            default:
-                return parseLiteral();
-        }
-    }
-    scanNext();
-    if (_scanner.getToken() === 17 ) {
-        if (options.allowEmptyContent) {
-            return true;
-        }
-        handleError(4 , [], []);
-        return false;
-    }
-    if (!parseValue()) {
-        handleError(4 , [], []);
-        return false;
-    }
-    if (_scanner.getToken() !== 17 ) {
-        handleError(9 , [], []);
-    }
-    return true;
-}
-class ConfigurationModel {
-    constructor(_contents = {}, _keys = [], _overrides = []) {
-        this._contents = _contents;
-        this._keys = _keys;
-        this._overrides = _overrides;
-        this.isFrozen = false;
-        this.overrideConfigurations =  new Map();
-    }
-    get contents() {
-        return this.checkAndFreeze(this._contents);
-    }
-    get overrides() {
-        return this.checkAndFreeze(this._overrides);
-    }
-    get keys() {
-        return this.checkAndFreeze(this._keys);
-    }
-    isEmpty() {
-        return this._keys.length === 0 && Object.keys(this._contents).length === 0 && this._overrides.length === 0;
-    }
-    getValue(section) {
-        return section ? getConfigurationValue(this.contents, section) : this.contents;
-    }
-    getOverrideValue(section, overrideIdentifier) {
-        const overrideContents = this.getContentsForOverrideIdentifer(overrideIdentifier);
-        return overrideContents
-            ? section ? getConfigurationValue(overrideContents, section) : overrideContents
-            : undefined;
-    }
-    getKeysForOverrideIdentifier(identifier) {
-        const keys = [];
-        for (const override of this.overrides) {
-            if (override.identifiers.includes(identifier)) {
-                keys.push(...override.keys);
-            }
-        }
-        return distinct(keys);
-    }
-    getAllOverrideIdentifiers() {
-        const result = [];
-        for (const override of this.overrides) {
-            result.push(...override.identifiers);
-        }
-        return distinct(result);
-    }
-    override(identifier) {
-        let overrideConfigurationModel = this.overrideConfigurations.get(identifier);
-        if (!overrideConfigurationModel) {
-            overrideConfigurationModel = this.createOverrideConfigurationModel(identifier);
-            this.overrideConfigurations.set(identifier, overrideConfigurationModel);
-        }
-        return overrideConfigurationModel;
-    }
-    merge(...others) {
-        const contents = deepClone(this.contents);
-        const overrides = deepClone(this.overrides);
-        const keys = [...this.keys];
-        for (const other of others) {
-            this.mergeContents(contents, other.contents);
-            for (const otherOverride of other.overrides) {
-                const [override] = overrides.filter(o => equals(o.identifiers, otherOverride.identifiers));
-                if (override) {
-                    this.mergeContents(override.contents, otherOverride.contents);
-                    override.keys.push(...otherOverride.keys);
-                    override.keys = distinct(override.keys);
-                }
-                else {
-                    overrides.push(deepClone(otherOverride));
-                }
-            }
-            for (const key of other.keys) {
-                if (keys.indexOf(key) === -1) {
-                    keys.push(key);
-                }
-            }
-        }
-        return (
-             new ConfigurationModel(contents, keys, overrides)
-        );
-    }
-    freeze() {
-        this.isFrozen = true;
-        return this;
-    }
-    createOverrideConfigurationModel(identifier) {
-        const overrideContents = this.getContentsForOverrideIdentifer(identifier);
-        if (!overrideContents || typeof overrideContents !== 'object' || !Object.keys(overrideContents).length) {
-            return this;
-        }
-        let contents = {};
-        for (const key of distinct([...Object.keys(this.contents), ...Object.keys(overrideContents)])) {
-            let contentsForKey = this.contents[key];
-            let overrideContentsForKey = overrideContents[key];
-            if (overrideContentsForKey) {
-                if (typeof contentsForKey === 'object' && typeof overrideContentsForKey === 'object') {
-                    contentsForKey = deepClone(contentsForKey);
-                    this.mergeContents(contentsForKey, overrideContentsForKey);
-                }
-                else {
-                    contentsForKey = overrideContentsForKey;
-                }
-            }
-            contents[key] = contentsForKey;
-        }
-        return (
-             new ConfigurationModel(contents, this.keys, this.overrides)
-        );
-    }
-    mergeContents(source, target) {
-        for (const key of Object.keys(target)) {
-            if (key in source) {
-                if (isObject(source[key]) && isObject(target[key])) {
-                    this.mergeContents(source[key], target[key]);
-                    continue;
-                }
-            }
-            source[key] = deepClone(target[key]);
-        }
-    }
-    checkAndFreeze(data) {
-        if (this.isFrozen && !Object.isFrozen(data)) {
-            return deepFreeze(data);
-        }
-        return data;
-    }
-    getContentsForOverrideIdentifer(identifier) {
-        let contentsForIdentifierOnly = null;
-        let contents = null;
-        const mergeContents = (contentsToMerge) => {
-            if (contentsToMerge) {
-                if (contents) {
-                    this.mergeContents(contents, contentsToMerge);
-                }
-                else {
-                    contents = deepClone(contentsToMerge);
-                }
-            }
-        };
-        for (const override of this.overrides) {
-            if (equals(override.identifiers, [identifier])) {
-                contentsForIdentifierOnly = override.contents;
-            }
-            else if (override.identifiers.includes(identifier)) {
-                mergeContents(override.contents);
-            }
-        }
-        mergeContents(contentsForIdentifierOnly);
-        return contents;
-    }
-    toJSON() {
-        return {
-            contents: this.contents,
-            overrides: this.overrides,
-            keys: this.keys
-        };
-    }
-    setValue(key, value) {
-        this.addKey(key);
-        addToValueTree(this.contents, key, value, e => { throw new Error(e); });
-    }
-    removeValue(key) {
-        if (this.removeKey(key)) {
-            removeFromValueTree(this.contents, key);
-        }
-    }
-    addKey(key) {
-        let index = this.keys.length;
-        for (let i = 0; i < index; i++) {
-            if (key.indexOf(this.keys[i]) === 0) {
-                index = i;
-            }
-        }
-        this.keys.splice(index, 1, key);
-    }
-    removeKey(key) {
-        let index = this.keys.indexOf(key);
-        if (index !== -1) {
-            this.keys.splice(index, 1);
-            return true;
-        }
-        return false;
-    }
-}
-class ConfigurationModelParser {
-    constructor(_name) {
-        this._name = _name;
-        this._raw = null;
-        this._configurationModel = null;
-        this._restrictedConfigurations = [];
-        this._parseErrors = [];
-    }
-    get configurationModel() {
-        return this._configurationModel ||  new ConfigurationModel();
-    }
-    get restrictedConfigurations() {
-        return this._restrictedConfigurations;
-    }
-    get errors() {
-        return this._parseErrors;
-    }
-    parse(content, options) {
-        if (!isUndefinedOrNull(content)) {
-            const raw = this.doParseContent(content);
-            this.parseRaw(raw, options);
-        }
-    }
-    reparse(options) {
-        if (this._raw) {
-            this.parseRaw(this._raw, options);
-        }
-    }
-    parseRaw(raw, options) {
-        this._raw = raw;
-        const { contents, keys, overrides, restricted } = this.doParseRaw(raw, options);
-        this._configurationModel =  new ConfigurationModel(contents, keys, overrides);
-        this._restrictedConfigurations = restricted || [];
-    }
-    doParseContent(content) {
-        let raw = {};
-        let currentProperty = null;
-        let currentParent = [];
-        let previousParents = [];
-        function onValue(value) {
-            if (Array.isArray(currentParent)) {
-                currentParent.push(value);
-            }
-            else if (currentProperty !== null) {
-                currentParent[currentProperty] = value;
-            }
-        }
-        let visitor = {
-            onObjectBegin: () => {
-                let object = {};
-                onValue(object);
-                previousParents.push(currentParent);
-                currentParent = object;
-                currentProperty = null;
-            },
-            onObjectProperty: (name) => {
-                currentProperty = name;
-            },
-            onObjectEnd: () => {
-                currentParent = previousParents.pop();
-            },
-            onArrayBegin: () => {
-                let array = [];
-                onValue(array);
-                previousParents.push(currentParent);
-                currentParent = array;
-                currentProperty = null;
-            },
-            onArrayEnd: () => {
-                currentParent = previousParents.pop();
-            },
-            onLiteralValue: onValue,
-            onError: (error, offset, length) => {
-            }
-        };
-        if (content) {
-            try {
-                visit(content, visitor);
-                raw = currentParent[0] || {};
-            }
-            catch (e) {
-                console.error(`Error while parsing settings file ${this._name}: ${e}`);
-                this._parseErrors = [e];
-            }
-        }
-        return raw;
-    }
-    doParseRaw(raw, options) {
-        const configurationProperties =  Registry.as(Extensions.Configuration).getConfigurationProperties();
-        const filtered = this.filter(raw, configurationProperties, true, options);
-        raw = filtered.raw;
-        const contents = toValuesTree(raw, message => console.error(`Conflict in settings file ${this._name}: ${message}`));
-        const keys = Object.keys(raw);
-        const overrides = this.toOverrides(raw, message => console.error(`Conflict in settings file ${this._name}: ${message}`));
-        return { contents, keys, overrides, restricted: filtered.restricted };
-    }
-    filter(properties, configurationProperties, filterOverriddenProperties, options) {
-        if (!options?.scopes && !options?.skipRestricted) {
-            return { raw: properties, restricted: [] };
-        }
-        const raw = {};
-        const restricted = [];
-        for (let key in properties) {
-            if (OVERRIDE_PROPERTY_REGEX.test(key) && filterOverriddenProperties) {
-                const result = this.filter(properties[key], configurationProperties, false, options);
-                raw[key] = result.raw;
-                restricted.push(...result.restricted);
-            }
-            else {
-                const propertySchema = configurationProperties[key];
-                const scope = propertySchema ? typeof propertySchema.scope !== 'undefined' ? propertySchema.scope : 3  : undefined;
-                if (propertySchema?.restricted) {
-                    restricted.push(key);
-                }
-                if (scope === undefined || options.scopes === undefined || options.scopes.includes(scope)) {
-                    if (!(options.skipRestricted && propertySchema?.restricted)) {
-                        raw[key] = properties[key];
-                    }
-                }
-            }
-        }
-        return { raw, restricted };
-    }
-    toOverrides(raw, conflictReporter) {
-        const overrides = [];
-        for (const key of Object.keys(raw)) {
-            if (OVERRIDE_PROPERTY_REGEX.test(key)) {
-                const overrideRaw = {};
-                for (const keyInOverrideRaw in raw[key]) {
-                    overrideRaw[keyInOverrideRaw] = raw[key][keyInOverrideRaw];
-                }
-                overrides.push({
-                    identifiers: overrideIdentifiersFromKey(key),
-                    keys: Object.keys(overrideRaw),
-                    contents: toValuesTree(overrideRaw, conflictReporter)
-                });
-            }
-        }
-        return overrides;
-    }
-}
-class UserSettings extends Disposable {
-    constructor(userSettingsResource, scopes, extUri, fileService) {
-        super();
-        this.userSettingsResource = userSettingsResource;
-        this.scopes = scopes;
-        this.fileService = fileService;
-        this._onDidChange = this._register( new Emitter());
-        this.onDidChange = this._onDidChange.event;
-        this.parser =  new ConfigurationModelParser(this.userSettingsResource.toString());
-        this.parseOptions = { scopes: this.scopes };
-        this._register(this.fileService.watch(extUri.dirname(this.userSettingsResource)));
-        this._register(this.fileService.watch(this.userSettingsResource));
-        this._register(Event.any(Event.filter(this.fileService.onDidFilesChange, e => e.contains(this.userSettingsResource)), Event.filter(this.fileService.onDidRunOperation, e => (e.isOperation(0 ) || e.isOperation(1 ) || e.isOperation(4 )) && extUri.isEqual(e.resource, userSettingsResource)))(() => this._onDidChange.fire()));
-    }
-    async loadConfiguration() {
-        try {
-            const content = await this.fileService.readFile(this.userSettingsResource);
-            this.parser.parse(content.value.toString() || '{}', this.parseOptions);
-            return this.parser.configurationModel;
-        }
-        catch (e) {
-            return (
-                 new ConfigurationModel()
-            );
-        }
-    }
-    reparse() {
-        this.parser.reparse(this.parseOptions);
-        return this.parser.configurationModel;
-    }
-    getRestrictedSettings() {
-        return this.parser.restrictedConfigurations;
-    }
-}
 class ConfigurationService extends Disposable {
     constructor(settingsResource, fileService) {
         super();
@@ -993,7 +79,7 @@ class ConfigurationService extends Disposable {
         this._onDidChangeConfiguration = this._register( new Emitter());
         this.onDidChangeConfiguration = this._onDidChangeConfiguration.event;
         this.userConfiguration = this._register( new UserSettings(this.settingsResource, undefined, extUriBiasedIgnorePathCase, fileService));
-        this.configuration =  new Configuration( new DefaultConfigurationModel(),  new ConfigurationModel$1());
+        this.configuration =  new Configuration( new DefaultConfigurationModel(),  new ConfigurationModel());
         this.reloadConfigurationScheduler = this._register( new RunOnceScheduler(() => this.reloadConfiguration(), 50));
         this._register( Registry.as(Extensions.Configuration).onDidUpdateConfiguration(({ properties }) => this.onDidDefaultConfigurationChange(properties)));
         this._register(this.userConfiguration.onDidChange(() => this.reloadConfigurationScheduler.schedule()));
@@ -2162,10 +1248,17 @@ function createConfigurationFileSystemProvider(settingsResource, readConfigurati
     };
     return provider;
 }
-function getServiceOverride(readConfiguration, onChange, settingsResource = URI.file('/userSettings.json')) {
+let userConfigurationJson = '{}';
+const userConfigurationChangeEmitter = new Emitter();
+function updateUserConfiguration(configurationJson) {
+    userConfigurationJson = configurationJson;
+    userConfigurationChangeEmitter.fire(undefined);
+}
+const configurationRegistry = Registry.as(Extensions.Configuration);
+function getServiceOverride(settingsResource = URI.file('/userSettings.json')) {
     const logService = StandaloneServices.get(ILogService);
     const fileService = new FileService(logService);
-    fileService.registerProvider(Schemas.file, createConfigurationFileSystemProvider(settingsResource, readConfiguration, onChange));
+    fileService.registerProvider(Schemas.file, createConfigurationFileSystemProvider(settingsResource, () => userConfigurationJson, userConfigurationChangeEmitter.event));
     const configurationService = new ConfigurationService(settingsResource, fileService);
     configurationService.initialize().catch(error => {
         logService.error(error);
@@ -2175,4 +1268,4 @@ function getServiceOverride(readConfiguration, onChange, settingsResource = URI.
         [ITextResourceConfigurationService.toString()]: new SyncDescriptor(TextResourceConfigurationService)
     };
 }
-export { getServiceOverride as default };
+export { configurationRegistry, getServiceOverride as default, updateUserConfiguration };