@codingame/monaco-vscode-api 1.67.13 → 1.67.16

package/dist/configuration.js

@@ -0,0 +1,2069 @@
+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-8687ea11.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 { URI } from 'monaco-editor/esm/vs/base/common/uri.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 { RunOnceScheduler, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { E as ensureFileSystemProviderError, G as createFileSystemProviderError, F as FileSystemProviderErrorCode, H as FileChangesEvent, J as FileOperationError, K as hasOpenReadWriteCloseCapability, L as hasReadWriteCapability, M as hasFileReadStreamCapability, O as toFileSystemProviderErrorCode, w as FileType, x as FilePermission, P as etag, Q as FileOperationEvent, R as toFileOperationResult, T as ETAG_DISABLED, U as hasFileAtomicReadCapability, V as NotModifiedSinceFileOperationError, W as hasFileFolderCopyCapability, b as __decorate, d as __param, C as CancellationTokenSource } from './services-7a462d46.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-f842d13c.js';
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
+import { TernarySearchTree } from 'monaco-editor/esm/vs/base/common/map.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 { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.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/browser/dom.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/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';
+import 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import 'monaco-editor/esm/vs/base/common/path.js';
+import 'monaco-editor/esm/vs/base/common/linkedList.js';
+import 'monaco-editor/esm/vs/base/common/stopwatch.js';
+import 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
+import 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import 'monaco-editor/esm/vs/editor/common/languages/languageConfigurationRegistry.js';
+import 'monaco-editor/esm/vs/editor/common/services/editorWorker.js';
+import 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+import 'monaco-editor/esm/vs/editor/common/services/model.js';
+import 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+import 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import 'monaco-editor/esm/vs/platform/markers/common/markers.js';
+import 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import 'monaco-editor/esm/vs/base/common/severity.js';
+function isConfigurationOverrides(thing) {
+    return thing
+        && typeof thing === 'object'
+        && (!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();
+        this.settingsResource = settingsResource;
+        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.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()));
+    }
+    async initialize() {
+        const userConfiguration = await this.userConfiguration.loadConfiguration();
+        this.configuration =  new Configuration( new DefaultConfigurationModel(), userConfiguration);
+    }
+    getConfigurationData() {
+        return this.configuration.toData();
+    }
+    getValue(arg1, arg2) {
+        const section = typeof arg1 === 'string' ? arg1 : undefined;
+        const overrides = isConfigurationOverrides(arg1) ? arg1 : isConfigurationOverrides(arg2) ? arg2 : {};
+        return this.configuration.getValue(section, overrides, undefined);
+    }
+    updateValue(key, value, arg3, arg4) {
+        return Promise.reject( new Error('not supported'));
+    }
+    inspect(key) {
+        return this.configuration.inspect(key, {}, undefined);
+    }
+    keys() {
+        return this.configuration.keys(undefined);
+    }
+    async reloadConfiguration() {
+        const configurationModel = await this.userConfiguration.loadConfiguration();
+        this.onDidChangeUserConfiguration(configurationModel);
+    }
+    onDidChangeUserConfiguration(userConfigurationModel) {
+        const previous = this.configuration.toData();
+        const change = this.configuration.compareAndUpdateLocalUserConfiguration(userConfigurationModel);
+        this.trigger(change, previous, 1 );
+    }
+    onDidDefaultConfigurationChange(properties) {
+        const previous = this.configuration.toData();
+        const change = this.configuration.compareAndUpdateDefaultConfiguration( new DefaultConfigurationModel(), properties);
+        this.trigger(change, previous, 6 );
+    }
+    trigger(configurationChange, previous, source) {
+        const event =  new ConfigurationChangeEvent(configurationChange, { data: previous }, this.configuration);
+        event.source = source;
+        event.sourceConfig = this.getTargetConfiguration(source);
+        this._onDidChangeConfiguration.fire(event);
+    }
+    getTargetConfiguration(target) {
+        switch (target) {
+            case 6 :
+                return this.configuration.defaults.contents;
+            case 1 :
+                return this.configuration.localUserConfiguration.contents;
+        }
+        return {};
+    }
+}
+async function readFileIntoStream(provider, resource, target, transformer, options, token) {
+    let error = undefined;
+    try {
+        await doReadFileIntoStream(provider, resource, target, transformer, options, token);
+    }
+    catch (err) {
+        error = err;
+    }
+    finally {
+        if (error && options.errorTransformer) {
+            error = options.errorTransformer(error);
+        }
+        if (typeof error !== 'undefined') {
+            target.error(error);
+        }
+        target.end();
+    }
+}
+async function doReadFileIntoStream(provider, resource, target, transformer, options, token) {
+    throwIfCancelled(token);
+    const handle = await provider.open(resource, { create: false });
+    try {
+        throwIfCancelled(token);
+        let totalBytesRead = 0;
+        let bytesRead = 0;
+        let allowedRemainingBytes = (options && typeof options.length === 'number') ? options.length : undefined;
+        let buffer = VSBuffer.alloc(Math.min(options.bufferSize, typeof allowedRemainingBytes === 'number' ? allowedRemainingBytes : options.bufferSize));
+        let posInFile = options && typeof options.position === 'number' ? options.position : 0;
+        let posInBuffer = 0;
+        do {
+            bytesRead = await provider.read(handle, posInFile, buffer.buffer, posInBuffer, buffer.byteLength - posInBuffer);
+            posInFile += bytesRead;
+            posInBuffer += bytesRead;
+            totalBytesRead += bytesRead;
+            if (typeof allowedRemainingBytes === 'number') {
+                allowedRemainingBytes -= bytesRead;
+            }
+            if (posInBuffer === buffer.byteLength) {
+                await target.write(transformer(buffer));
+                buffer = VSBuffer.alloc(Math.min(options.bufferSize, typeof allowedRemainingBytes === 'number' ? allowedRemainingBytes : options.bufferSize));
+                posInBuffer = 0;
+            }
+        } while (bytesRead > 0 && (typeof allowedRemainingBytes !== 'number' || allowedRemainingBytes > 0) && throwIfCancelled(token) && throwIfTooLarge(totalBytesRead, options));
+        if (posInBuffer > 0) {
+            let lastChunkLength = posInBuffer;
+            if (typeof allowedRemainingBytes === 'number') {
+                lastChunkLength = Math.min(posInBuffer, allowedRemainingBytes);
+            }
+            target.write(transformer(buffer.slice(0, lastChunkLength)));
+        }
+    }
+    catch (error) {
+        throw ensureFileSystemProviderError(error);
+    }
+    finally {
+        await provider.close(handle);
+    }
+}
+function throwIfCancelled(token) {
+    if (token.isCancellationRequested) {
+        throw canceled();
+    }
+    return true;
+}
+function throwIfTooLarge(totalBytesRead, options) {
+    if (options?.limits) {
+        if (typeof options.limits.memory === 'number' && totalBytesRead > options.limits.memory) {
+            throw createFileSystemProviderError(localize('fileTooLargeForHeapError', "To open a file of this size, you need to restart and allow to use more memory"), FileSystemProviderErrorCode.FileExceedsMemoryLimit);
+        }
+        if (typeof options.limits.size === 'number' && totalBytesRead > options.limits.size) {
+            throw createFileSystemProviderError(localize('fileTooLargeError', "File is too large to open"), FileSystemProviderErrorCode.FileTooLarge);
+        }
+    }
+    return true;
+}
+let FileService = class FileService extends Disposable {
+    constructor(logService) {
+        super();
+        this.logService = logService;
+        this.BUFFER_SIZE = 256 * 1024;
+        this._onDidChangeFileSystemProviderRegistrations = this._register( new Emitter());
+        this.onDidChangeFileSystemProviderRegistrations = this._onDidChangeFileSystemProviderRegistrations.event;
+        this._onWillActivateFileSystemProvider = this._register( new Emitter());
+        this.onWillActivateFileSystemProvider = this._onWillActivateFileSystemProvider.event;
+        this._onDidChangeFileSystemProviderCapabilities = this._register( new Emitter());
+        this.onDidChangeFileSystemProviderCapabilities = this._onDidChangeFileSystemProviderCapabilities.event;
+        this.provider =  new Map();
+        this._onDidRunOperation = this._register( new Emitter());
+        this.onDidRunOperation = this._onDidRunOperation.event;
+        this._onDidFilesChange = this._register( new Emitter());
+        this.onDidFilesChange = this._onDidFilesChange.event;
+        this._onDidWatchError = this._register( new Emitter());
+        this.onDidWatchError = this._onDidWatchError.event;
+        this.activeWatchers =  new Map();
+        this.writeQueue = this._register( new ResourceQueue());
+    }
+    registerProvider(scheme, provider) {
+        if (this.provider.has(scheme)) {
+            throw new Error(`A filesystem provider for the scheme '${scheme}' is already registered.`);
+        }
+        const providerDisposables =  new DisposableStore();
+        this.provider.set(scheme, provider);
+        this._onDidChangeFileSystemProviderRegistrations.fire({ added: true, scheme, provider });
+        providerDisposables.add(provider.onDidChangeFile(changes => this._onDidFilesChange.fire( new FileChangesEvent(changes, !this.isPathCaseSensitive(provider)))));
+        if (typeof provider.onDidWatchError === 'function') {
+            providerDisposables.add(provider.onDidWatchError(error => this._onDidWatchError.fire( new Error(error))));
+        }
+        providerDisposables.add(provider.onDidChangeCapabilities(() => this._onDidChangeFileSystemProviderCapabilities.fire({ provider, scheme })));
+        return toDisposable(() => {
+            this._onDidChangeFileSystemProviderRegistrations.fire({ added: false, scheme, provider });
+            this.provider.delete(scheme);
+            dispose(providerDisposables);
+        });
+    }
+    getProvider(scheme) {
+        return this.provider.get(scheme);
+    }
+    async activateProvider(scheme) {
+        const joiners = [];
+        this._onWillActivateFileSystemProvider.fire({
+            scheme,
+            join(promise) {
+                joiners.push(promise);
+            },
+        });
+        if (this.provider.has(scheme)) {
+            return;
+        }
+        await Promises.settled(joiners);
+    }
+    async canHandleResource(resource) {
+        await this.activateProvider(resource.scheme);
+        return this.hasProvider(resource);
+    }
+    hasProvider(resource) {
+        return this.provider.has(resource.scheme);
+    }
+    hasCapability(resource, capability) {
+        const provider = this.provider.get(resource.scheme);
+        return !!(provider && (provider.capabilities & capability));
+    }
+    listCapabilities() {
+        return Iterable.map(this.provider, ([scheme, provider]) => ({ scheme, capabilities: provider.capabilities }));
+    }
+    async withProvider(resource) {
+        if (!isAbsolutePath(resource)) {
+            throw new FileOperationError(localize('invalidPath', "Unable to resolve filesystem provider with relative file path '{0}'", this.resourceForError(resource)), 8 );
+        }
+        await this.activateProvider(resource.scheme);
+        const provider = this.provider.get(resource.scheme);
+        if (!provider) {
+            const error =  new Error();
+            error.name = 'ENOPRO';
+            error.message =  localize(
+                'noProviderFound',
+                "No file system provider found for resource '{0}'",
+                resource.toString()
+            );
+            throw error;
+        }
+        return provider;
+    }
+    async withReadProvider(resource) {
+        const provider = await this.withProvider(resource);
+        if (hasOpenReadWriteCloseCapability(provider) || hasReadWriteCapability(provider) || hasFileReadStreamCapability(provider)) {
+            return provider;
+        }
+        throw new Error(`Filesystem provider for scheme '${resource.scheme}' neither has FileReadWrite, FileReadStream nor FileOpenReadWriteClose capability which is needed for the read operation.`);
+    }
+    async withWriteProvider(resource) {
+        const provider = await this.withProvider(resource);
+        if (hasOpenReadWriteCloseCapability(provider) || hasReadWriteCapability(provider)) {
+            return provider;
+        }
+        throw new Error(`Filesystem provider for scheme '${resource.scheme}' neither has FileReadWrite nor FileOpenReadWriteClose capability which is needed for the write operation.`);
+    }
+    async resolve(resource, options) {
+        try {
+            return await this.doResolveFile(resource, options);
+        }
+        catch (error) {
+            if (toFileSystemProviderErrorCode(error) === FileSystemProviderErrorCode.FileNotFound) {
+                throw new FileOperationError(localize('fileNotFoundError', "Unable to resolve nonexistent file '{0}'", this.resourceForError(resource)), 1 );
+            }
+            throw ensureFileSystemProviderError(error);
+        }
+    }
+    async doResolveFile(resource, options) {
+        const provider = await this.withProvider(resource);
+        const isPathCaseSensitive = this.isPathCaseSensitive(provider);
+        const resolveTo = options?.resolveTo;
+        const resolveSingleChildDescendants = options?.resolveSingleChildDescendants;
+        const resolveMetadata = options?.resolveMetadata;
+        const stat = await provider.stat(resource);
+        let trie;
+        return this.toFileStat(provider, resource, stat, undefined, !!resolveMetadata, (stat, siblings) => {
+            if (!trie) {
+                trie = TernarySearchTree.forUris(() => !isPathCaseSensitive);
+                trie.set(resource, true);
+                if (resolveTo) {
+                    trie.fill(true, resolveTo);
+                }
+            }
+            if (trie.get(stat.resource) || trie.findSuperstr(stat.resource.with({ query: null, fragment: null } ))) {
+                return true;
+            }
+            if (stat.isDirectory && resolveSingleChildDescendants) {
+                return siblings === 1;
+            }
+            return false;
+        });
+    }
+    async toFileStat(provider, resource, stat, siblings, resolveMetadata, recurse) {
+        const { providerExtUri } = this.getExtUri(provider);
+        const fileStat = {
+            resource,
+            name: providerExtUri.basename(resource),
+            isFile: (stat.type & FileType.File) !== 0,
+            isDirectory: (stat.type & FileType.Directory) !== 0,
+            isSymbolicLink: (stat.type & FileType.SymbolicLink) !== 0,
+            mtime: stat.mtime,
+            ctime: stat.ctime,
+            size: stat.size,
+            readonly: Boolean((stat.permissions ?? 0) & FilePermission.Readonly) || Boolean(provider.capabilities & 2048 ),
+            etag: etag({ mtime: stat.mtime, size: stat.size }),
+            children: undefined
+        };
+        if (fileStat.isDirectory && recurse(fileStat, siblings)) {
+            try {
+                const entries = await provider.readdir(resource);
+                const resolvedEntries = await Promises.settled(entries.map(async ([name, type]) => {
+                    try {
+                        const childResource = providerExtUri.joinPath(resource, name);
+                        const childStat = resolveMetadata ? await provider.stat(childResource) : { type };
+                        return await this.toFileStat(provider, childResource, childStat, entries.length, resolveMetadata, recurse);
+                    }
+                    catch (error) {
+                        this.logService.trace(error);
+                        return null;
+                    }
+                }));
+                fileStat.children = coalesce(resolvedEntries);
+            }
+            catch (error) {
+                this.logService.trace(error);
+                fileStat.children = [];
+            }
+            return fileStat;
+        }
+        return fileStat;
+    }
+    async resolveAll(toResolve) {
+        return Promises.settled(toResolve.map(async (entry) => {
+            try {
+                return { stat: await this.doResolveFile(entry.resource, entry.options), success: true };
+            }
+            catch (error) {
+                this.logService.trace(error);
+                return { stat: undefined, success: false };
+            }
+        }));
+    }
+    async stat(resource) {
+        const provider = await this.withProvider(resource);
+        const stat = await provider.stat(resource);
+        return this.toFileStat(provider, resource, stat, undefined, true, () => false );
+    }
+    async exists(resource) {
+        const provider = await this.withProvider(resource);
+        try {
+            const stat = await provider.stat(resource);
+            return !!stat;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async canCreateFile(resource, options) {
+        try {
+            await this.doValidateCreateFile(resource, options);
+        }
+        catch (error) {
+            return error;
+        }
+        return true;
+    }
+    async doValidateCreateFile(resource, options) {
+        if (!options?.overwrite && (await this.exists(resource))) {
+            throw new FileOperationError(localize('fileExists', "Unable to create file '{0}' that already exists when overwrite flag is not set", this.resourceForError(resource)), 3 , options);
+        }
+    }
+    async createFile(resource, bufferOrReadableOrStream = VSBuffer.fromString(''), options) {
+        await this.doValidateCreateFile(resource, options);
+        const fileStat = await this.writeFile(resource, bufferOrReadableOrStream);
+        this._onDidRunOperation.fire( new FileOperationEvent(resource, 0 , fileStat));
+        return fileStat;
+    }
+    async writeFile(resource, bufferOrReadableOrStream, options) {
+        const provider = this.throwIfFileSystemIsReadonly(await this.withWriteProvider(resource), resource);
+        const { providerExtUri } = this.getExtUri(provider);
+        try {
+            const stat = await this.validateWriteFile(provider, resource, options);
+            if (!stat) {
+                await this.mkdirp(provider, providerExtUri.dirname(resource));
+            }
+            let bufferOrReadableOrStreamOrBufferedStream;
+            if (hasReadWriteCapability(provider) && !(bufferOrReadableOrStream instanceof VSBuffer)) {
+                if (isReadableStream(bufferOrReadableOrStream)) {
+                    const bufferedStream = await peekStream(bufferOrReadableOrStream, 3);
+                    if (bufferedStream.ended) {
+                        bufferOrReadableOrStreamOrBufferedStream = VSBuffer.concat(bufferedStream.buffer);
+                    }
+                    else {
+                        bufferOrReadableOrStreamOrBufferedStream = bufferedStream;
+                    }
+                }
+                else {
+                    bufferOrReadableOrStreamOrBufferedStream = peekReadable(bufferOrReadableOrStream, data => VSBuffer.concat(data), 3);
+                }
+            }
+            else {
+                bufferOrReadableOrStreamOrBufferedStream = bufferOrReadableOrStream;
+            }
+            if (!hasOpenReadWriteCloseCapability(provider) || (hasReadWriteCapability(provider) && bufferOrReadableOrStreamOrBufferedStream instanceof VSBuffer)) {
+                await this.doWriteUnbuffered(provider, resource, options, bufferOrReadableOrStreamOrBufferedStream);
+            }
+            else {
+                await this.doWriteBuffered(provider, resource, options, bufferOrReadableOrStreamOrBufferedStream instanceof VSBuffer ? bufferToReadable(bufferOrReadableOrStreamOrBufferedStream) : bufferOrReadableOrStreamOrBufferedStream);
+            }
+            this._onDidRunOperation.fire( new FileOperationEvent(resource, 4 ));
+        }
+        catch (error) {
+            throw new FileOperationError(localize('err.write', "Unable to write file '{0}' ({1})", this.resourceForError(resource), ensureFileSystemProviderError(error).toString()), toFileOperationResult(error), options);
+        }
+        return this.resolve(resource, { resolveMetadata: true });
+    }
+    async validateWriteFile(provider, resource, options) {
+        const unlock = !!options?.unlock;
+        if (unlock && !((provider.capabilities & 8192) )) {
+            throw new Error(localize('writeFailedUnlockUnsupported', "Unable to unlock file '{0}' because provider does not support it.", this.resourceForError(resource)));
+        }
+        let stat = undefined;
+        try {
+            stat = await provider.stat(resource);
+        }
+        catch (error) {
+            return undefined;
+        }
+        if ((stat.type & FileType.Directory) !== 0) {
+            throw new FileOperationError(localize('fileIsDirectoryWriteError', "Unable to write file '{0}' that is actually a directory", this.resourceForError(resource)), 0 , options);
+        }
+        this.throwIfFileIsReadonly(resource, stat);
+        if (typeof options?.mtime === 'number' && typeof options.etag === 'string' && options.etag !== ETAG_DISABLED &&
+            typeof stat.mtime === 'number' && typeof stat.size === 'number' &&
+            options.mtime < stat.mtime && options.etag !== etag({ mtime: options.mtime , size: stat.size })) {
+            throw new FileOperationError(localize('fileModifiedError', "File Modified Since"), 3 , options);
+        }
+        return stat;
+    }
+    async readFile(resource, options, token) {
+        const provider = await this.withReadProvider(resource);
+        if (options?.atomic) {
+            return this.doReadFileAtomic(provider, resource, options, token);
+        }
+        return this.doReadFile(provider, resource, options, token);
+    }
+    async doReadFileAtomic(provider, resource, options, token) {
+        return (
+             new Promise((resolve, reject) => {
+                this.writeQueue.queueFor(resource, this.getExtUri(provider).providerExtUri).queue(async () => {
+                    try {
+                        const content = await this.doReadFile(provider, resource, options, token);
+                        resolve(content);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+            })
+        );
+    }
+    async doReadFile(provider, resource, options, token) {
+        const stream = await this.doReadFileStream(provider, resource, {
+            ...options,
+            preferUnbuffered: true
+        }, token);
+        return {
+            ...stream,
+            value: await streamToBuffer(stream.value)
+        };
+    }
+    async readFileStream(resource, options, token) {
+        const provider = await this.withReadProvider(resource);
+        return this.doReadFileStream(provider, resource, options, token);
+    }
+    async doReadFileStream(provider, resource, options, token) {
+        const cancellableSource =  new CancellationTokenSource(token);
+        const statPromise = this.validateReadFile(resource, options).then(stat => stat, error => {
+            cancellableSource.cancel();
+            throw error;
+        });
+        let fileStream = undefined;
+        try {
+            if (typeof options?.etag === 'string' && options.etag !== ETAG_DISABLED) {
+                await statPromise;
+            }
+            if ((options?.atomic && hasFileAtomicReadCapability(provider)) ||
+                !(hasOpenReadWriteCloseCapability(provider) || hasFileReadStreamCapability(provider)) ||
+                (hasReadWriteCapability(provider) && options?.preferUnbuffered)
+            ) {
+                fileStream = this.readFileUnbuffered(provider, resource, options);
+            }
+            else if (hasFileReadStreamCapability(provider)) {
+                fileStream = this.readFileStreamed(provider, resource, cancellableSource.token, options);
+            }
+            else {
+                fileStream = this.readFileBuffered(provider, resource, cancellableSource.token, options);
+            }
+            const fileStat = await statPromise;
+            return {
+                ...fileStat,
+                value: fileStream
+            };
+        }
+        catch (error) {
+            if (fileStream) {
+                await consumeStream(fileStream);
+            }
+            const message =  localize(
+                'err.read',
+                "Unable to read file '{0}' ({1})",
+                this.resourceForError(resource),
+                ensureFileSystemProviderError(error).toString()
+            );
+            if (error instanceof NotModifiedSinceFileOperationError) {
+                throw new NotModifiedSinceFileOperationError(message, error.stat, options);
+            }
+            else {
+                throw new FileOperationError(message, toFileOperationResult(error), options);
+            }
+        }
+    }
+    readFileStreamed(provider, resource, token, options = Object.create(null)) {
+        const fileStream = provider.readFileStream(resource, options, token);
+        return transform(fileStream, {
+            data: data => data instanceof VSBuffer ? data : VSBuffer.wrap(data),
+            error: error =>  new FileOperationError( localize(
+                'err.read',
+                "Unable to read file '{0}' ({1})",
+                this.resourceForError(resource),
+                ensureFileSystemProviderError(error).toString()
+            ), toFileOperationResult(error), options)
+        }, data => VSBuffer.concat(data));
+    }
+    readFileBuffered(provider, resource, token, options = Object.create(null)) {
+        const stream = newWriteableBufferStream();
+        readFileIntoStream(provider, resource, stream, data => data, {
+            ...options,
+            bufferSize: this.BUFFER_SIZE,
+            errorTransformer: error =>  new FileOperationError( localize(
+                'err.read',
+                "Unable to read file '{0}' ({1})",
+                this.resourceForError(resource),
+                ensureFileSystemProviderError(error).toString()
+            ), toFileOperationResult(error), options)
+        }, token);
+        return stream;
+    }
+    readFileUnbuffered(provider, resource, options) {
+        const stream = newWriteableStream(data => VSBuffer.concat(data));
+        (async () => {
+            try {
+                let buffer;
+                if (options?.atomic && hasFileAtomicReadCapability(provider)) {
+                    buffer = await provider.readFile(resource, { atomic: true });
+                }
+                else {
+                    buffer = await provider.readFile(resource);
+                }
+                if (typeof options?.position === 'number') {
+                    buffer = buffer.slice(options.position);
+                }
+                if (typeof options?.length === 'number') {
+                    buffer = buffer.slice(0, options.length);
+                }
+                this.validateReadFileLimits(resource, buffer.byteLength, options);
+                stream.end(VSBuffer.wrap(buffer));
+            }
+            catch (err) {
+                stream.error(err);
+                stream.end();
+            }
+        })();
+        return stream;
+    }
+    async validateReadFile(resource, options) {
+        const stat = await this.resolve(resource, { resolveMetadata: true });
+        if (stat.isDirectory) {
+            throw new FileOperationError(localize('fileIsDirectoryReadError', "Unable to read file '{0}' that is actually a directory", this.resourceForError(resource)), 0 , options);
+        }
+        if (typeof options?.etag === 'string' && options.etag !== ETAG_DISABLED && options.etag === stat.etag) {
+            throw new NotModifiedSinceFileOperationError(localize('fileNotModifiedError', "File not modified since"), stat, options);
+        }
+        this.validateReadFileLimits(resource, stat.size, options);
+        return stat;
+    }
+    validateReadFileLimits(resource, size, options) {
+        if (options?.limits) {
+            let tooLargeErrorResult = undefined;
+            if (typeof options.limits.memory === 'number' && size > options.limits.memory) {
+                tooLargeErrorResult = 9 ;
+            }
+            if (typeof options.limits.size === 'number' && size > options.limits.size) {
+                tooLargeErrorResult = 7 ;
+            }
+            if (typeof tooLargeErrorResult === 'number') {
+                throw new FileOperationError(localize('fileTooLargeError', "Unable to read file '{0}' that is too large to open", this.resourceForError(resource)), tooLargeErrorResult);
+            }
+        }
+    }
+    async canMove(source, target, overwrite) {
+        return this.doCanMoveCopy(source, target, 'move', overwrite);
+    }
+    async canCopy(source, target, overwrite) {
+        return this.doCanMoveCopy(source, target, 'copy', overwrite);
+    }
+    async doCanMoveCopy(source, target, mode, overwrite) {
+        if (source.toString() !== target.toString()) {
+            try {
+                const sourceProvider = mode === 'move' ? this.throwIfFileSystemIsReadonly(await this.withWriteProvider(source), source) : await this.withReadProvider(source);
+                const targetProvider = this.throwIfFileSystemIsReadonly(await this.withWriteProvider(target), target);
+                await this.doValidateMoveCopy(sourceProvider, source, targetProvider, target, mode, overwrite);
+            }
+            catch (error) {
+                return error;
+            }
+        }
+        return true;
+    }
+    async move(source, target, overwrite) {
+        const sourceProvider = this.throwIfFileSystemIsReadonly(await this.withWriteProvider(source), source);
+        const targetProvider = this.throwIfFileSystemIsReadonly(await this.withWriteProvider(target), target);
+        const mode = await this.doMoveCopy(sourceProvider, source, targetProvider, target, 'move', !!overwrite);
+        const fileStat = await this.resolve(target, { resolveMetadata: true });
+        this._onDidRunOperation.fire( new FileOperationEvent(
+            source,
+            mode === 'move' ? 2  : 3 ,
+            fileStat
+        ));
+        return fileStat;
+    }
+    async copy(source, target, overwrite) {
+        const sourceProvider = await this.withReadProvider(source);
+        const targetProvider = this.throwIfFileSystemIsReadonly(await this.withWriteProvider(target), target);
+        const mode = await this.doMoveCopy(sourceProvider, source, targetProvider, target, 'copy', !!overwrite);
+        const fileStat = await this.resolve(target, { resolveMetadata: true });
+        this._onDidRunOperation.fire( new FileOperationEvent(
+            source,
+            mode === 'copy' ? 3  : 2 ,
+            fileStat
+        ));
+        return fileStat;
+    }
+    async doMoveCopy(sourceProvider, source, targetProvider, target, mode, overwrite) {
+        if (source.toString() === target.toString()) {
+            return mode;
+        }
+        const { exists, isSameResourceWithDifferentPathCase } = await this.doValidateMoveCopy(sourceProvider, source, targetProvider, target, mode, overwrite);
+        if (exists && !isSameResourceWithDifferentPathCase && overwrite) {
+            await this.del(target, { recursive: true });
+        }
+        await this.mkdirp(targetProvider, this.getExtUri(targetProvider).providerExtUri.dirname(target));
+        if (mode === 'copy') {
+            if (sourceProvider === targetProvider && hasFileFolderCopyCapability(sourceProvider)) {
+                await sourceProvider.copy(source, target, { overwrite });
+            }
+            else {
+                const sourceFile = await this.resolve(source);
+                if (sourceFile.isDirectory) {
+                    await this.doCopyFolder(sourceProvider, sourceFile, targetProvider, target);
+                }
+                else {
+                    await this.doCopyFile(sourceProvider, source, targetProvider, target);
+                }
+            }
+            return mode;
+        }
+        else {
+            if (sourceProvider === targetProvider) {
+                await sourceProvider.rename(source, target, { overwrite });
+                return mode;
+            }
+            else {
+                await this.doMoveCopy(sourceProvider, source, targetProvider, target, 'copy', overwrite);
+                await this.del(source, { recursive: true });
+                return 'copy';
+            }
+        }
+    }
+    async doCopyFile(sourceProvider, source, targetProvider, target) {
+        if (hasOpenReadWriteCloseCapability(sourceProvider) && hasOpenReadWriteCloseCapability(targetProvider)) {
+            return this.doPipeBuffered(sourceProvider, source, targetProvider, target);
+        }
+        if (hasOpenReadWriteCloseCapability(sourceProvider) && hasReadWriteCapability(targetProvider)) {
+            return this.doPipeBufferedToUnbuffered(sourceProvider, source, targetProvider, target);
+        }
+        if (hasReadWriteCapability(sourceProvider) && hasOpenReadWriteCloseCapability(targetProvider)) {
+            return this.doPipeUnbufferedToBuffered(sourceProvider, source, targetProvider, target);
+        }
+        if (hasReadWriteCapability(sourceProvider) && hasReadWriteCapability(targetProvider)) {
+            return this.doPipeUnbuffered(sourceProvider, source, targetProvider, target);
+        }
+    }
+    async doCopyFolder(sourceProvider, sourceFolder, targetProvider, targetFolder) {
+        await targetProvider.mkdir(targetFolder);
+        if (Array.isArray(sourceFolder.children)) {
+            await Promises.settled(sourceFolder.children.map(async (sourceChild) => {
+                const targetChild = this.getExtUri(targetProvider).providerExtUri.joinPath(targetFolder, sourceChild.name);
+                if (sourceChild.isDirectory) {
+                    return this.doCopyFolder(sourceProvider, await this.resolve(sourceChild.resource), targetProvider, targetChild);
+                }
+                else {
+                    return this.doCopyFile(sourceProvider, sourceChild.resource, targetProvider, targetChild);
+                }
+            }));
+        }
+    }
+    async doValidateMoveCopy(sourceProvider, source, targetProvider, target, mode, overwrite) {
+        let isSameResourceWithDifferentPathCase = false;
+        if (sourceProvider === targetProvider) {
+            const { providerExtUri, isPathCaseSensitive } = this.getExtUri(sourceProvider);
+            if (!isPathCaseSensitive) {
+                isSameResourceWithDifferentPathCase = providerExtUri.isEqual(source, target);
+            }
+            if (isSameResourceWithDifferentPathCase && mode === 'copy') {
+                throw new Error(localize('unableToMoveCopyError1', "Unable to copy when source '{0}' is same as target '{1}' with different path case on a case insensitive file system", this.resourceForError(source), this.resourceForError(target)));
+            }
+            if (!isSameResourceWithDifferentPathCase && providerExtUri.isEqualOrParent(target, source)) {
+                throw new Error(localize('unableToMoveCopyError2', "Unable to move/copy when source '{0}' is parent of target '{1}'.", this.resourceForError(source), this.resourceForError(target)));
+            }
+        }
+        const exists = await this.exists(target);
+        if (exists && !isSameResourceWithDifferentPathCase) {
+            if (!overwrite) {
+                throw new FileOperationError(localize('unableToMoveCopyError3', "Unable to move/copy '{0}' because target '{1}' already exists at destination.", this.resourceForError(source), this.resourceForError(target)), 4 );
+            }
+            if (sourceProvider === targetProvider) {
+                const { providerExtUri } = this.getExtUri(sourceProvider);
+                if (providerExtUri.isEqualOrParent(source, target)) {
+                    throw new Error(localize('unableToMoveCopyError4', "Unable to move/copy '{0}' into '{1}' since a file would replace the folder it is contained in.", this.resourceForError(source), this.resourceForError(target)));
+                }
+            }
+        }
+        return { exists, isSameResourceWithDifferentPathCase };
+    }
+    getExtUri(provider) {
+        const isPathCaseSensitive = this.isPathCaseSensitive(provider);
+        return {
+            providerExtUri: isPathCaseSensitive ? extUri : extUriIgnorePathCase,
+            isPathCaseSensitive
+        };
+    }
+    isPathCaseSensitive(provider) {
+        return !!((provider.capabilities & 1024) );
+    }
+    async createFolder(resource) {
+        const provider = this.throwIfFileSystemIsReadonly(await this.withProvider(resource), resource);
+        await this.mkdirp(provider, resource);
+        const fileStat = await this.resolve(resource, { resolveMetadata: true });
+        this._onDidRunOperation.fire( new FileOperationEvent(resource, 0 , fileStat));
+        return fileStat;
+    }
+    async mkdirp(provider, directory) {
+        const directoriesToCreate = [];
+        const { providerExtUri } = this.getExtUri(provider);
+        while (!providerExtUri.isEqual(directory, providerExtUri.dirname(directory))) {
+            try {
+                const stat = await provider.stat(directory);
+                if ((stat.type & FileType.Directory) === 0) {
+                    throw new Error(localize('mkdirExistsError', "Unable to create folder '{0}' that already exists but is not a directory", this.resourceForError(directory)));
+                }
+                break;
+            }
+            catch (error) {
+                if (toFileSystemProviderErrorCode(error) !== FileSystemProviderErrorCode.FileNotFound) {
+                    throw error;
+                }
+                directoriesToCreate.push(providerExtUri.basename(directory));
+                directory = providerExtUri.dirname(directory);
+            }
+        }
+        for (let i = directoriesToCreate.length - 1; i >= 0; i--) {
+            directory = providerExtUri.joinPath(directory, directoriesToCreate[i]);
+            try {
+                await provider.mkdir(directory);
+            }
+            catch (error) {
+                if (toFileSystemProviderErrorCode(error) !== FileSystemProviderErrorCode.FileExists) {
+                    throw error;
+                }
+            }
+        }
+    }
+    async canDelete(resource, options) {
+        try {
+            await this.doValidateDelete(resource, options);
+        }
+        catch (error) {
+            return error;
+        }
+        return true;
+    }
+    async doValidateDelete(resource, options) {
+        const provider = this.throwIfFileSystemIsReadonly(await this.withProvider(resource), resource);
+        const useTrash = !!options?.useTrash;
+        if (useTrash && !((provider.capabilities & 4096) )) {
+            throw new Error(localize('deleteFailedTrashUnsupported', "Unable to delete file '{0}' via trash because provider does not support it.", this.resourceForError(resource)));
+        }
+        let stat = undefined;
+        try {
+            stat = await provider.stat(resource);
+        }
+        catch (error) {
+        }
+        if (stat) {
+            this.throwIfFileIsReadonly(resource, stat);
+        }
+        else {
+            throw new FileOperationError(localize('deleteFailedNotFound', "Unable to delete nonexistent file '{0}'", this.resourceForError(resource)), 1 );
+        }
+        const recursive = !!options?.recursive;
+        if (!recursive) {
+            const stat = await this.resolve(resource);
+            if (stat.isDirectory && Array.isArray(stat.children) && stat.children.length > 0) {
+                throw new Error(localize('deleteFailedNonEmptyFolder', "Unable to delete non-empty folder '{0}'.", this.resourceForError(resource)));
+            }
+        }
+        return provider;
+    }
+    async del(resource, options) {
+        const provider = await this.doValidateDelete(resource, options);
+        const useTrash = !!options?.useTrash;
+        const recursive = !!options?.recursive;
+        await provider.delete(resource, { recursive, useTrash });
+        this._onDidRunOperation.fire( new FileOperationEvent(resource, 1 ));
+    }
+    watch(resource, options = { recursive: false, excludes: [] }) {
+        const disposables =  new DisposableStore();
+        let watchDisposed = false;
+        let disposeWatch = () => { watchDisposed = true; };
+        disposables.add(toDisposable(() => disposeWatch()));
+        (async () => {
+            try {
+                const disposable = await this.doWatch(resource, options);
+                if (watchDisposed) {
+                    dispose(disposable);
+                }
+                else {
+                    disposeWatch = () => dispose(disposable);
+                }
+            }
+            catch (error) {
+                this.logService.error(error);
+            }
+        })();
+        return disposables;
+    }
+    async doWatch(resource, options) {
+        const provider = await this.withProvider(resource);
+        const watchHash = hash([this.getExtUri(provider).providerExtUri.getComparisonKey(resource), options]);
+        let watcher = this.activeWatchers.get(watchHash);
+        if (!watcher) {
+            watcher = {
+                count: 0,
+                disposable: provider.watch(resource, options)
+            };
+            this.activeWatchers.set(watchHash, watcher);
+        }
+        watcher.count += 1;
+        return toDisposable(() => {
+            if (watcher) {
+                watcher.count--;
+                if (watcher.count === 0) {
+                    dispose(watcher.disposable);
+                    this.activeWatchers.delete(watchHash);
+                }
+            }
+        });
+    }
+    dispose() {
+        super.dispose();
+        for (const [, watcher] of this.activeWatchers) {
+            dispose(watcher.disposable);
+        }
+        this.activeWatchers.clear();
+    }
+    async doWriteBuffered(provider, resource, options, readableOrStreamOrBufferedStream) {
+        return this.writeQueue.queueFor(resource, this.getExtUri(provider).providerExtUri).queue(async () => {
+            const handle = await provider.open(resource, { create: true, unlock: options?.unlock ?? false });
+            try {
+                if (isReadableStream(readableOrStreamOrBufferedStream) || isReadableBufferedStream(readableOrStreamOrBufferedStream)) {
+                    await this.doWriteStreamBufferedQueued(provider, handle, readableOrStreamOrBufferedStream);
+                }
+                else {
+                    await this.doWriteReadableBufferedQueued(provider, handle, readableOrStreamOrBufferedStream);
+                }
+            }
+            catch (error) {
+                throw ensureFileSystemProviderError(error);
+            }
+            finally {
+                await provider.close(handle);
+            }
+        });
+    }
+    async doWriteStreamBufferedQueued(provider, handle, streamOrBufferedStream) {
+        let posInFile = 0;
+        let stream;
+        if (isReadableBufferedStream(streamOrBufferedStream)) {
+            if (streamOrBufferedStream.buffer.length > 0) {
+                const chunk = VSBuffer.concat(streamOrBufferedStream.buffer);
+                await this.doWriteBuffer(provider, handle, chunk, chunk.byteLength, posInFile, 0);
+                posInFile += chunk.byteLength;
+            }
+            if (streamOrBufferedStream.ended) {
+                return;
+            }
+            stream = streamOrBufferedStream.stream;
+        }
+        else {
+            stream = streamOrBufferedStream;
+        }
+        return (
+             new Promise((resolve, reject) => {
+                listenStream(stream, {
+                    onData: async (chunk) => {
+                        stream.pause();
+                        try {
+                            await this.doWriteBuffer(provider, handle, chunk, chunk.byteLength, posInFile, 0);
+                        }
+                        catch (error) {
+                            return reject(error);
+                        }
+                        posInFile += chunk.byteLength;
+                        setTimeout(() => stream.resume());
+                    },
+                    onError: error => reject(error),
+                    onEnd: () => resolve()
+                });
+            })
+        );
+    }
+    async doWriteReadableBufferedQueued(provider, handle, readable) {
+        let posInFile = 0;
+        let chunk;
+        while ((chunk = readable.read()) !== null) {
+            await this.doWriteBuffer(provider, handle, chunk, chunk.byteLength, posInFile, 0);
+            posInFile += chunk.byteLength;
+        }
+    }
+    async doWriteBuffer(provider, handle, buffer, length, posInFile, posInBuffer) {
+        let totalBytesWritten = 0;
+        while (totalBytesWritten < length) {
+            const bytesWritten = await provider.write(handle, posInFile + totalBytesWritten, buffer.buffer, posInBuffer + totalBytesWritten, length - totalBytesWritten);
+            totalBytesWritten += bytesWritten;
+        }
+    }
+    async doWriteUnbuffered(provider, resource, options, bufferOrReadableOrStreamOrBufferedStream) {
+        return this.writeQueue.queueFor(resource, this.getExtUri(provider).providerExtUri).queue(() => this.doWriteUnbufferedQueued(provider, resource, options, bufferOrReadableOrStreamOrBufferedStream));
+    }
+    async doWriteUnbufferedQueued(provider, resource, options, bufferOrReadableOrStreamOrBufferedStream) {
+        let buffer;
+        if (bufferOrReadableOrStreamOrBufferedStream instanceof VSBuffer) {
+            buffer = bufferOrReadableOrStreamOrBufferedStream;
+        }
+        else if (isReadableStream(bufferOrReadableOrStreamOrBufferedStream)) {
+            buffer = await streamToBuffer(bufferOrReadableOrStreamOrBufferedStream);
+        }
+        else if (isReadableBufferedStream(bufferOrReadableOrStreamOrBufferedStream)) {
+            buffer = await bufferedStreamToBuffer(bufferOrReadableOrStreamOrBufferedStream);
+        }
+        else {
+            buffer = readableToBuffer(bufferOrReadableOrStreamOrBufferedStream);
+        }
+        await provider.writeFile(resource, buffer.buffer, { create: true, overwrite: true, unlock: options?.unlock ?? false });
+    }
+    async doPipeBuffered(sourceProvider, source, targetProvider, target) {
+        return this.writeQueue.queueFor(target, this.getExtUri(targetProvider).providerExtUri).queue(() => this.doPipeBufferedQueued(sourceProvider, source, targetProvider, target));
+    }
+    async doPipeBufferedQueued(sourceProvider, source, targetProvider, target) {
+        let sourceHandle = undefined;
+        let targetHandle = undefined;
+        try {
+            sourceHandle = await sourceProvider.open(source, { create: false });
+            targetHandle = await targetProvider.open(target, { create: true, unlock: false });
+            const buffer = VSBuffer.alloc(this.BUFFER_SIZE);
+            let posInFile = 0;
+            let posInBuffer = 0;
+            let bytesRead = 0;
+            do {
+                bytesRead = await sourceProvider.read(sourceHandle, posInFile, buffer.buffer, posInBuffer, buffer.byteLength - posInBuffer);
+                await this.doWriteBuffer(targetProvider, targetHandle, buffer, bytesRead, posInFile, posInBuffer);
+                posInFile += bytesRead;
+                posInBuffer += bytesRead;
+                if (posInBuffer === buffer.byteLength) {
+                    posInBuffer = 0;
+                }
+            } while (bytesRead > 0);
+        }
+        catch (error) {
+            throw ensureFileSystemProviderError(error);
+        }
+        finally {
+            await Promises.settled([
+                typeof sourceHandle === 'number' ? sourceProvider.close(sourceHandle) : Promise.resolve(),
+                typeof targetHandle === 'number' ? targetProvider.close(targetHandle) : Promise.resolve(),
+            ]);
+        }
+    }
+    async doPipeUnbuffered(sourceProvider, source, targetProvider, target) {
+        return this.writeQueue.queueFor(target, this.getExtUri(targetProvider).providerExtUri).queue(() => this.doPipeUnbufferedQueued(sourceProvider, source, targetProvider, target));
+    }
+    async doPipeUnbufferedQueued(sourceProvider, source, targetProvider, target) {
+        return targetProvider.writeFile(target, await sourceProvider.readFile(source), { create: true, overwrite: true, unlock: false });
+    }
+    async doPipeUnbufferedToBuffered(sourceProvider, source, targetProvider, target) {
+        return this.writeQueue.queueFor(target, this.getExtUri(targetProvider).providerExtUri).queue(() => this.doPipeUnbufferedToBufferedQueued(sourceProvider, source, targetProvider, target));
+    }
+    async doPipeUnbufferedToBufferedQueued(sourceProvider, source, targetProvider, target) {
+        const targetHandle = await targetProvider.open(target, { create: true, unlock: false });
+        try {
+            const buffer = await sourceProvider.readFile(source);
+            await this.doWriteBuffer(targetProvider, targetHandle, VSBuffer.wrap(buffer), buffer.byteLength, 0, 0);
+        }
+        catch (error) {
+            throw ensureFileSystemProviderError(error);
+        }
+        finally {
+            await targetProvider.close(targetHandle);
+        }
+    }
+    async doPipeBufferedToUnbuffered(sourceProvider, source, targetProvider, target) {
+        const buffer = await streamToBuffer(this.readFileBuffered(sourceProvider, source, CancellationToken.None));
+        await this.doWriteUnbuffered(targetProvider, target, undefined, buffer);
+    }
+    throwIfFileSystemIsReadonly(provider, resource) {
+        if (provider.capabilities & 2048 ) {
+            throw new FileOperationError(localize('err.readonly', "Unable to modify readonly file '{0}'", this.resourceForError(resource)), 6 );
+        }
+        return provider;
+    }
+    throwIfFileIsReadonly(resource, stat) {
+        if ((stat.permissions ?? 0) & FilePermission.Readonly) {
+            throw new FileOperationError(localize('err.readonly', "Unable to modify readonly file '{0}'", this.resourceForError(resource)), 6 );
+        }
+    }
+    resourceForError(resource) {
+        if (resource.scheme === Schemas.file) {
+            return resource.fsPath;
+        }
+        return resource.toString(true);
+    }
+};
+FileService =  __decorate([
+     __param(0, ILogService)
+], FileService);
+function createConfigurationFileSystemProvider(settingsResource, readConfiguration, onChange) {
+    const onDidFilesChange = new Emitter();
+    onChange(() => {
+        onDidFilesChange.fire([{
+                type: 0 ,
+                resource: settingsResource
+            }]);
+    });
+    const textEncoder = new TextEncoder();
+    const provider = {
+        capabilities: 2 ,
+        onDidChangeCapabilities: Event.None,
+        onDidChangeFile: onDidFilesChange.event,
+        watch: function () {
+            return {
+                dispose() { }
+            };
+        },
+        stat: async (resource) => {
+            if (resource.toString() !== settingsResource.toString()) {
+                unsupported();
+            }
+            return {
+                type: FileType.File,
+                mtime: 0,
+                ctime: 0,
+                size: textEncoder.encode(readConfiguration()).length
+            };
+        },
+        mkdir: unsupported,
+        readdir: unsupported,
+        delete: unsupported,
+        rename: unsupported,
+        writeFile: unsupported,
+        readFile: async (resource) => {
+            if (resource.toString() !== settingsResource.toString()) {
+                unsupported();
+            }
+            return textEncoder.encode(readConfiguration());
+        }
+    };
+    return provider;
+}
+function getServiceOverride(readConfiguration, onChange, settingsResource = URI.file('/userSettings.json')) {
+    const logService = StandaloneServices.get(ILogService);
+    const fileService = new FileService(logService);
+    fileService.registerProvider(Schemas.file, createConfigurationFileSystemProvider(settingsResource, readConfiguration, onChange));
+    const configurationService = new ConfigurationService(settingsResource, fileService);
+    configurationService.initialize().catch(error => {
+        logService.error(error);
+    });
+    return {
+        [IConfigurationService.toString()]: configurationService
+    };
+}
+export { getServiceOverride as default };