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

package/dist/files.js

@@ -1,269 +1,47 @@
-import { _ as __decorate, E as Emitter, a as __param, T as TextFileOperationError, K as toBufferOrReadable, l as ITextFileService, I as IEditorService, n as IFileService, q as IWorkingCopyFileService, j as IUriIdentityService, o as IWorkbenchEnvironmentService, r as IPathService, e as IProductService, L as stringToSnapshot, m as mark, M as FileChangesEvent, v as FileOperationError, O as hasOpenReadWriteCloseCapability, P as hasReadWriteCapability, Q as hasFileReadStreamCapability, x as toFileSystemProviderErrorCode, F as FileSystemProviderErrorCode, R as ensureFileSystemProviderError, f as FileType, h as FilePermission, U as etag, V as FileOperationEvent, W as toFileOperationResult, X as ETAG_DISABLED, Y as hasFileAtomicReadCapability, Z as NotModifiedSinceFileOperationError, $ as TooLargeFileOperationError, a0 as hasFileFolderCopyCapability, a1 as hasFileCloneCapability, a2 as createFileSystemProviderError, a3 as FileSystemProviderError } from './services2.js';
-import { z as bufferToReadable, B as bufferToStream, C as consumeStream, D as insert, E as isReadableStream, F as peekStream, G as peekReadable, H as streamToBuffer, J as transform, K as isReadableBufferedStream, L as listenStream, M as bufferedStreamToBuffer, O as readableToBuffer, Q as newWriteableBufferStream, T as newWriteableStream } from './polyfill.js';
-import { b$ as SaveSourceRegistry, c0 as IWorkingCopyBackupService, I as IWorkingCopyService, bP as ILanguageDetectionService, c1 as IUntitledTextEditorService, bL as ILifecycleService, c2 as IFileDialogService, c3 as IFilesConfigurationService, c4 as IElevatedFileService, c5 as IDecorationsService, u as unsupported, D as Disposable$1 } from './missing-services.js';
-import { C as CancellationTokenSource } from './cancellation.js';
+import { __decorate, EditorExtensions, FILES_EXCLUDE_CONFIG, FILES_ASSOCIATIONS_CONFIG, SUPPORTED_ENCODINGS, AutoSaveConfiguration, Emitter, createFileSystemProviderError, AbstractTextResourceEditorInput, DEFAULT_EDITOR_ASSOCIATION, findViewStateForEditor, isResourceEditorInput, __param, HotExitConfiguration, FileType, FileSystemProviderError, FileSystemProviderErrorCode, IFileService, ITextFileService, BrowserTextFileService, EditorModel, getLargeFileConfirmationLimit, ByteSize, IFilesConfigurationService, IEditorService, IPathService, IUriIdentityService, IHostService, ResourceQueue, mark, FileChangesEvent, FileOperationError, hasOpenReadWriteCloseCapability, hasReadWriteCapability, hasFileReadStreamCapability, toFileSystemProviderErrorCode, ensureFileSystemProviderError, FilePermission, etag, FileOperationEvent, isReadableStream, peekStream, peekReadable, bufferToReadable, toFileOperationResult, ETAG_DISABLED, streamToBuffer, hasFileAtomicReadCapability, consumeStream, NotModifiedSinceFileOperationError, TooLargeFileOperationError, transform, hasFileFolderCopyCapability, hasFileCloneCapability, isReadableBufferedStream, listenStream, bufferedStreamToBuffer, readableToBuffer, isEqual as isEqual$1, CancellationTokenSource, newWriteableBufferStream, newWriteableStream } from './polyfill.js';
+export { FileChangeType$1 as FileChangeType, FileSystemProviderCapabilities } from './polyfill.js';
 import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { onUnexpectedError, canceled, ErrorNoTelemetry } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { canceled, ErrorNoTelemetry } from 'monaco-editor/esm/vs/base/common/errors.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { R as ResourceQueue } from './async.js';
-import { Disposable, dispose, toDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { Promises, raceCancellation } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Disposable, DisposableStore, dispose, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { RunOnceScheduler, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
 import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
-import { isEqual, basename, dirname, joinPath, extname as extname$1, isAbsolutePath, extUri, extUriIgnorePathCase } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { basename, dirname, isEqual, relativePath, joinPath, isAbsolutePath, extUri, extUriIgnorePathCase, basenameOrAuthority, isEqualOrParent } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { TernarySearchTree } from 'monaco-editor/esm/vs/base/common/ternarySearchTree.js';
-import { firstOrDefault, coalesce } from 'monaco-editor/esm/vs/base/common/arrays.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 { I as IExtensionResourceLoaderService, A as AbstractExtensionResourceLoaderService } from './extensionResourceLoader.js';
-import { B as BaseTextEditorModel, N as NO_TYPE_ID, U as UTF8, c as createTextBufferFactoryFromStream, t as toEncodeReadable, a as toDecodeStream, b as UTF16be, d as UTF16le, e as UTF8_with_bom, f as encodingExists, T as TextFileEditorModel } from './textFileEditorModel.js';
-import { withNullAsUndefined, assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
-import { getCharContainingOffset } from 'monaco-editor/esm/vs/base/common/strings.js';
-import { ensureValidWordDefinition } from 'monaco-editor/esm/vs/editor/common/core/wordHelper.js';
-import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
-import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
-import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
+import { FILE_EDITOR_INPUT_ID, BINARY_TEXT_FILE_MODE, BINARY_FILE_EDITOR_ID, TEXT_FILE_EDITOR_ID } from './files2.js';
+import { Mimes } from 'monaco-editor/esm/vs/base/common/mime.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { createTextBufferFactory } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
+import { createDecorator, IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
 import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
-import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
-import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
-import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
-import { toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
-import { createTextBufferFactoryFromSnapshot } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
-import { PLAINTEXT_LANGUAGE_ID, PLAINTEXT_EXTENSION } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
+import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { equalsIgnoreCase, startsWithIgnoreCase, rtrim } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { posix } from 'monaco-editor/esm/vs/base/common/path.js';
+import { memoize } from 'monaco-editor/esm/vs/base/common/decorators.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-import { listErrorForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
-import { t as toLocalResource } from './resources.js';
-import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
-import { extname } from 'monaco-editor/esm/vs/base/common/path.js';
-import { IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
-import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
-import { WORKSPACE_EXTENSION, IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
-import { registerSingleton } from 'monaco-editor/esm/vs/platform/instantiation/common/extensions.js';
-import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { equals, deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { parse } from 'monaco-editor/esm/vs/base/common/glob.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-let UntitledTextEditorModel = class UntitledTextEditorModel extends BaseTextEditorModel {
-    get name() {
-        if (this.configuredLabelFormat === 'content' && !this.hasAssociatedFilePath && this.cachedModelFirstLineWords) {
-            return this.cachedModelFirstLineWords;
-        }
-        return this.labelService.getUriBasenameLabel(this.resource);
-    }
-    constructor(resource, hasAssociatedFilePath, initialValue, preferredLanguageId, preferredEncoding, languageService, modelService, workingCopyBackupService, textResourceConfigurationService, workingCopyService, textFileService, labelService, editorService, languageDetectionService, accessibilityService) {
-        super(modelService, languageService, languageDetectionService, accessibilityService);
-        this.resource = resource;
-        this.hasAssociatedFilePath = hasAssociatedFilePath;
-        this.initialValue = initialValue;
-        this.preferredLanguageId = preferredLanguageId;
-        this.preferredEncoding = preferredEncoding;
-        this.workingCopyBackupService = workingCopyBackupService;
-        this.textResourceConfigurationService = textResourceConfigurationService;
-        this.workingCopyService = workingCopyService;
-        this.textFileService = textFileService;
-        this.labelService = labelService;
-        this.editorService = editorService;
-        this._onDidChangeContent = this._register(( (new Emitter())));
-        this.onDidChangeContent = this._onDidChangeContent.event;
-        this._onDidChangeName = this._register(( (new Emitter())));
-        this.onDidChangeName = this._onDidChangeName.event;
-        this._onDidChangeDirty = this._register(( (new Emitter())));
-        this.onDidChangeDirty = this._onDidChangeDirty.event;
-        this._onDidChangeEncoding = this._register(( (new Emitter())));
-        this.onDidChangeEncoding = this._onDidChangeEncoding.event;
-        this._onDidSave = this._register(( (new Emitter())));
-        this.onDidSave = this._onDidSave.event;
-        this._onDidRevert = this._register(( (new Emitter())));
-        this.onDidRevert = this._onDidRevert.event;
-        this.typeId = NO_TYPE_ID;
-        this.capabilities = 2 ;
-        this.configuredLabelFormat = 'content';
-        this.cachedModelFirstLineWords = undefined;
-        this.dirty = this.hasAssociatedFilePath || !!this.initialValue;
-        this._register(this.workingCopyService.registerWorkingCopy(this));
-        if (preferredLanguageId) {
-            this.setLanguageId(preferredLanguageId);
-        }
-        this.onConfigurationChange(undefined, false);
-        this.registerListeners();
-    }
-    registerListeners() {
-        this._register(this.textResourceConfigurationService.onDidChangeConfiguration(e => this.onConfigurationChange(e, true)));
-    }
-    onConfigurationChange(e, fromEvent) {
-        if (!e || e.affectsConfiguration(this.resource, 'files.encoding')) {
-            const configuredEncoding = this.textResourceConfigurationService.getValue(this.resource, 'files.encoding');
-            if (this.configuredEncoding !== configuredEncoding && typeof configuredEncoding === 'string') {
-                this.configuredEncoding = configuredEncoding;
-                if (fromEvent && !this.preferredEncoding) {
-                    this._onDidChangeEncoding.fire();
-                }
-            }
-        }
-        if (!e || e.affectsConfiguration(this.resource, 'workbench.editor.untitled.labelFormat')) {
-            const configuredLabelFormat = this.textResourceConfigurationService.getValue(this.resource, 'workbench.editor.untitled.labelFormat');
-            if (this.configuredLabelFormat !== configuredLabelFormat && (configuredLabelFormat === 'content' || configuredLabelFormat === 'name')) {
-                this.configuredLabelFormat = configuredLabelFormat;
-                if (fromEvent) {
-                    this._onDidChangeName.fire();
-                }
-            }
-        }
-    }
-    setLanguageId(languageId, source) {
-        const actualLanguage = languageId === UntitledTextEditorModel.ACTIVE_EDITOR_LANGUAGE_ID
-            ? this.editorService.activeTextEditorLanguageId
-            : languageId;
-        this.preferredLanguageId = actualLanguage;
-        if (actualLanguage) {
-            super.setLanguageId(actualLanguage, source);
-        }
-    }
-    getLanguageId() {
-        if (this.textEditorModel) {
-            return this.textEditorModel.getLanguageId();
-        }
-        return this.preferredLanguageId;
-    }
-    getEncoding() {
-        return this.preferredEncoding || this.configuredEncoding;
-    }
-    async setEncoding(encoding) {
-        const oldEncoding = this.getEncoding();
-        this.preferredEncoding = encoding;
-        if (oldEncoding !== this.preferredEncoding) {
-            this._onDidChangeEncoding.fire();
-        }
-    }
-    isDirty() {
-        return this.dirty;
-    }
-    setDirty(dirty) {
-        if (this.dirty === dirty) {
-            return;
-        }
-        this.dirty = dirty;
-        this._onDidChangeDirty.fire();
-    }
-    async save(options) {
-        const target = await this.textFileService.save(this.resource, options);
-        if (target) {
-            this._onDidSave.fire({ reason: options?.reason, source: options?.source });
-        }
-        return !!target;
-    }
-    async revert() {
-        this.setDirty(false);
-        this._onDidRevert.fire();
-        this.dispose();
-    }
-    async backup(token) {
-        let content = undefined;
-        if (this.isResolved()) {
-            content = await this.textFileService.getEncodedReadable(this.resource, withNullAsUndefined(this.createSnapshot()), { encoding: UTF8 });
-        }
-        else if (typeof this.initialValue === 'string') {
-            content = bufferToReadable(VSBuffer.fromString(this.initialValue));
-        }
-        return { content };
-    }
-    async resolve() {
-        let createdUntitledModel = false;
-        let hasBackup = false;
-        if (!this.textEditorModel) {
-            let untitledContents;
-            const backup = await this.workingCopyBackupService.resolve(this);
-            if (backup) {
-                untitledContents = backup.value;
-                hasBackup = true;
-            }
-            else {
-                untitledContents = bufferToStream(VSBuffer.fromString(this.initialValue || ''));
-            }
-            const untitledContentsFactory = await createTextBufferFactoryFromStream(await this.textFileService.getDecodedStream(this.resource, untitledContents, { encoding: UTF8 }));
-            this.createTextEditorModel(untitledContentsFactory, this.resource, this.preferredLanguageId);
-            createdUntitledModel = true;
-        }
-        else {
-            this.updateTextEditorModel(undefined, this.preferredLanguageId);
-        }
-        const textEditorModel = assertIsDefined(this.textEditorModel);
-        this.installModelListeners(textEditorModel);
-        if (createdUntitledModel) {
-            if (hasBackup || this.initialValue) {
-                this.updateNameFromFirstLine(textEditorModel);
-            }
-            this.setDirty(this.hasAssociatedFilePath || !!hasBackup || !!this.initialValue);
-            if (hasBackup || this.initialValue) {
-                this._onDidChangeContent.fire();
-            }
-        }
-        return super.resolve();
-    }
-    installModelListeners(model) {
-        this._register(model.onDidChangeContent(e => this.onModelContentChanged(model, e)));
-        this._register(model.onDidChangeLanguage(() => this.onConfigurationChange(undefined, true)));
-        super.installModelListeners(model);
-    }
-    onModelContentChanged(textEditorModel, e) {
-        if (!this.hasAssociatedFilePath && textEditorModel.getLineCount() === 1 && textEditorModel.getLineContent(1) === '') {
-            this.setDirty(false);
-        }
-        else {
-            this.setDirty(true);
-        }
-        if (e.changes.some(change => (change.range.startLineNumber === 1 || change.range.endLineNumber === 1) && change.range.startColumn <= UntitledTextEditorModel.FIRST_LINE_NAME_CANDIDATE_MAX_LENGTH)) {
-            this.updateNameFromFirstLine(textEditorModel);
-        }
-        this._onDidChangeContent.fire();
-        this.autoDetectLanguage();
-    }
-    updateNameFromFirstLine(textEditorModel) {
-        if (this.hasAssociatedFilePath) {
-            return;
-        }
-        let modelFirstWordsCandidate = undefined;
-        let firstLineText = textEditorModel
-            .getValueInRange({
-            startLineNumber: 1,
-            endLineNumber: 1,
-            startColumn: 1,
-            endColumn: UntitledTextEditorModel.FIRST_LINE_NAME_CANDIDATE_MAX_LENGTH + 1
-        })
-            .trim().replace(/\s+/g, ' ');
-        firstLineText = firstLineText.substr(0, getCharContainingOffset(
-        firstLineText, UntitledTextEditorModel.FIRST_LINE_NAME_MAX_LENGTH)[0]);
-        if (firstLineText && ensureValidWordDefinition().exec(firstLineText)) {
-            modelFirstWordsCandidate = firstLineText;
-        }
-        if (modelFirstWordsCandidate !== this.cachedModelFirstLineWords) {
-            this.cachedModelFirstLineWords = modelFirstWordsCandidate;
-            this._onDidChangeName.fire();
-        }
-    }
-    isReadonly() {
-        return false;
-    }
-};
-UntitledTextEditorModel.FIRST_LINE_NAME_MAX_LENGTH = 40;
-UntitledTextEditorModel.FIRST_LINE_NAME_CANDIDATE_MAX_LENGTH = UntitledTextEditorModel.FIRST_LINE_NAME_MAX_LENGTH * 10;
-UntitledTextEditorModel.ACTIVE_EDITOR_LANGUAGE_ID = '${activeEditorLanguage}';
-UntitledTextEditorModel = ( (__decorate([
-    ( (__param(5, ILanguageService))),
-    ( (__param(6, IModelService))),
-    ( (__param(7, IWorkingCopyBackupService))),
-    ( (__param(8, ITextResourceConfigurationService))),
-    ( (__param(9, IWorkingCopyService))),
-    ( (__param(10, ITextFileService))),
-    ( (__param(11, ILabelService))),
-    ( (__param(12, IEditorService))),
-    ( (__param(13, ILanguageDetectionService))),
-    ( (__param(14, IAccessibilityService)))
-], UntitledTextEditorModel)));
+import { IUndoRedoService, UndoRedoSource } from 'monaco-editor/esm/vs/platform/undoRedo/common/undoRedo.js';
+import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
+import { IBulkEditService } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
+import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { isWeb, isNative } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { editorConfigurationBaseNode } from 'monaco-editor/esm/vs/editor/common/config/editorConfigurationSchema.js';
+import { RedoCommand } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { ModesRegistry } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 async function readFileIntoStream(provider, resource, target, transformer, options, token) {
     let error = undefined;
     try {
@@ -1423,1021 +1201,1740 @@ class InMemoryFileSystemProvider extends Disposable {
         }, 5);
     }
 }
-let TextFileSaveParticipant = class TextFileSaveParticipant extends Disposable {
-    constructor(progressService, logService) {
-        super();
-        this.progressService = progressService;
-        this.logService = logService;
-        this.saveParticipants = [];
-    }
-    addSaveParticipant(participant) {
-        const remove = insert(this.saveParticipants, participant);
-        return toDisposable(() => remove());
-    }
-    participate(model, context, token) {
-        const cts = ( (new CancellationTokenSource(token)));
-        return this.progressService.withProgress({
-            title: ( (localize('saveParticipants', "Saving '{0}'", model.name))),
-            location: 15 ,
-            cancellable: true,
-            delay: model.isDirty() ? 3000 : 5000
-        }, async (progress) => {
-            model.textEditorModel?.pushStackElement();
-            for (const saveParticipant of this.saveParticipants) {
-                if (cts.token.isCancellationRequested || !model.textEditorModel ) {
-                    break;
-                }
-                try {
-                    const promise = saveParticipant.participate(model, context, progress, cts.token);
-                    await raceCancellation(promise, cts.token);
-                }
-                catch (err) {
-                    this.logService.error(err);
-                }
-            }
-            model.textEditorModel?.pushStackElement();
-        }, () => {
-            cts.dispose(true);
-        });
-    }
-    dispose() {
-        this.saveParticipants.splice(0, this.saveParticipants.length);
-    }
-};
-TextFileSaveParticipant = ( (__decorate([
-    ( (__param(0, IProgressService))),
-    ( (__param(1, ILogService)))
-], TextFileSaveParticipant)));
-let TextFileEditorModelManager = class TextFileEditorModelManager extends Disposable {
-    get models() {
-        return [...( (this.mapResourceToModel.values()))];
-    }
-    constructor(instantiationService, fileService, notificationService, workingCopyFileService, uriIdentityService) {
+let BinaryEditorModel = class BinaryEditorModel extends EditorModel {
+    constructor(resource, name, fileService) {
         super();
-        this.instantiationService = instantiationService;
+        this.resource = resource;
+        this.name = name;
         this.fileService = fileService;
-        this.notificationService = notificationService;
-        this.workingCopyFileService = workingCopyFileService;
-        this.uriIdentityService = uriIdentityService;
-        this._onDidCreate = this._register(( (new Emitter())));
-        this.onDidCreate = this._onDidCreate.event;
-        this._onDidResolve = this._register(( (new Emitter())));
-        this.onDidResolve = this._onDidResolve.event;
-        this._onDidRemove = this._register(( (new Emitter())));
-        this.onDidRemove = this._onDidRemove.event;
-        this._onDidChangeDirty = this._register(( (new Emitter())));
-        this.onDidChangeDirty = this._onDidChangeDirty.event;
-        this._onDidChangeReadonly = this._register(( (new Emitter())));
-        this.onDidChangeReadonly = this._onDidChangeReadonly.event;
-        this._onDidChangeOrphaned = this._register(( (new Emitter())));
-        this.onDidChangeOrphaned = this._onDidChangeOrphaned.event;
-        this._onDidSaveError = this._register(( (new Emitter())));
-        this.onDidSaveError = this._onDidSaveError.event;
-        this._onDidSave = this._register(( (new Emitter())));
-        this.onDidSave = this._onDidSave.event;
-        this._onDidRevert = this._register(( (new Emitter())));
-        this.onDidRevert = this._onDidRevert.event;
-        this._onDidChangeEncoding = this._register(( (new Emitter())));
-        this.onDidChangeEncoding = this._onDidChangeEncoding.event;
-        this.mapResourceToModel = ( (new ResourceMap()));
-        this.mapResourceToModelListeners = ( (new ResourceMap()));
-        this.mapResourceToDisposeListener = ( (new ResourceMap()));
-        this.mapResourceToPendingModelResolvers = ( (new ResourceMap()));
-        this.modelResolveQueue = this._register(( (new ResourceQueue())));
-        this.saveErrorHandler = (() => {
-            const notificationService = this.notificationService;
-            return {
-                onSaveError(error, model) {
-                    notificationService.error(( (localize(
-                        { key: 'genericSaveError', comment: ['{0} is the resource that failed to save and {1} the error message'] },
-                        "Failed to save '{0}': {1}",
-                        model.name,
-                        toErrorMessage(error, false)
-                    ))));
-                }
-            };
-        })();
-        this.mapCorrelationIdToModelsToRestore = ( (new Map()));
-        this.saveParticipants = this._register(this.instantiationService.createInstance(TextFileSaveParticipant));
-        this.registerListeners();
-    }
-    registerListeners() {
-        this._register(this.fileService.onDidFilesChange(e => this.onDidFilesChange(e)));
-        this._register(this.fileService.onDidChangeFileSystemProviderCapabilities(e => this.onDidChangeFileSystemProviderCapabilities(e)));
-        this._register(this.fileService.onDidChangeFileSystemProviderRegistrations(e => this.onDidChangeFileSystemProviderRegistrations(e)));
-        this._register(this.workingCopyFileService.onWillRunWorkingCopyFileOperation(e => this.onWillRunWorkingCopyFileOperation(e)));
-        this._register(this.workingCopyFileService.onDidFailWorkingCopyFileOperation(e => this.onDidFailWorkingCopyFileOperation(e)));
-        this._register(this.workingCopyFileService.onDidRunWorkingCopyFileOperation(e => this.onDidRunWorkingCopyFileOperation(e)));
-    }
-    onDidFilesChange(e) {
-        for (const model of this.models) {
-            if (model.isDirty()) {
-                continue;
-            }
-            if (e.contains(model.resource, 0 , 1 )) {
-                this.queueModelReload(model);
-            }
-        }
+        this.mime = Mimes.binary;
     }
-    onDidChangeFileSystemProviderCapabilities(e) {
-        this.queueModelReloads(e.scheme);
+    getName() {
+        return this.name;
     }
-    onDidChangeFileSystemProviderRegistrations(e) {
-        if (!e.added) {
-            return;
-        }
-        this.queueModelReloads(e.scheme);
-    }
-    queueModelReloads(scheme) {
-        for (const model of this.models) {
-            if (model.isDirty()) {
-                continue;
-            }
-            if (scheme === model.resource.scheme) {
-                this.queueModelReload(model);
-            }
-        }
+    getSize() {
+        return this.size;
     }
-    queueModelReload(model) {
-        const queue = this.modelResolveQueue.queueFor(model.resource);
-        if (queue.size <= 1) {
-            queue.queue(async () => {
-                try {
-                    await this.reload(model);
-                }
-                catch (error) {
-                    onUnexpectedError(error);
-                }
-            });
-        }
+    getMime() {
+        return this.mime;
     }
-    onWillRunWorkingCopyFileOperation(e) {
-        if (e.operation === 2  || e.operation === 3 ) {
-            const modelsToRestore = [];
-            for (const { source, target } of e.files) {
-                if (source) {
-                    if (this.uriIdentityService.extUri.isEqual(source, target)) {
-                        continue;
-                    }
-                    const sourceModels = [];
-                    for (const model of this.models) {
-                        if (this.uriIdentityService.extUri.isEqualOrParent(model.resource, source)) {
-                            sourceModels.push(model);
-                        }
-                    }
-                    for (const sourceModel of sourceModels) {
-                        const sourceModelResource = sourceModel.resource;
-                        let targetModelResource;
-                        if (this.uriIdentityService.extUri.isEqual(sourceModelResource, source)) {
-                            targetModelResource = target;
-                        }
-                        else {
-                            targetModelResource = joinPath(target, sourceModelResource.path.substr(source.path.length + 1));
-                        }
-                        modelsToRestore.push({
-                            source: sourceModelResource,
-                            target: targetModelResource,
-                            languageId: sourceModel.getLanguageId(),
-                            encoding: sourceModel.getEncoding(),
-                            snapshot: sourceModel.isDirty() ? sourceModel.createSnapshot() : undefined
-                        });
-                    }
-                }
-            }
-            this.mapCorrelationIdToModelsToRestore.set(e.correlationId, modelsToRestore);
-        }
+    getETag() {
+        return this.etag;
     }
-    onDidFailWorkingCopyFileOperation(e) {
-        if (((e.operation === 2  || e.operation === 3) )) {
-            const modelsToRestore = this.mapCorrelationIdToModelsToRestore.get(e.correlationId);
-            if (modelsToRestore) {
-                this.mapCorrelationIdToModelsToRestore.delete(e.correlationId);
-                modelsToRestore.forEach(model => {
-                    if (model.snapshot) {
-                        this.get(model.source)?.setDirty(true);
-                    }
-                });
+    async resolve() {
+        if (this.fileService.hasProvider(this.resource)) {
+            const stat = await this.fileService.stat(this.resource);
+            this.etag = stat.etag;
+            if (typeof stat.size === 'number') {
+                this.size = stat.size;
             }
         }
+        return super.resolve();
     }
-    onDidRunWorkingCopyFileOperation(e) {
-        switch (e.operation) {
-            case 0 :
-                e.waitUntil((async () => {
-                    for (const { target } of e.files) {
-                        const model = this.get(target);
-                        if (model && !model.isDisposed()) {
-                            await model.revert();
-                        }
-                    }
-                })());
-                break;
-            case 2 :
-            case 3 :
-                e.waitUntil((async () => {
-                    const modelsToRestore = this.mapCorrelationIdToModelsToRestore.get(e.correlationId);
-                    if (modelsToRestore) {
-                        this.mapCorrelationIdToModelsToRestore.delete(e.correlationId);
-                        await Promises.settled(( (modelsToRestore.map(async (modelToRestore) => {
-                            const restoredModel = await this.resolve(modelToRestore.target, {
-                                reload: { async: false },
-                                contents: modelToRestore.snapshot ? createTextBufferFactoryFromSnapshot(modelToRestore.snapshot) : undefined,
-                                encoding: modelToRestore.encoding
-                            });
-                            if (modelToRestore.languageId &&
-                                modelToRestore.languageId !== PLAINTEXT_LANGUAGE_ID &&
-                                restoredModel.getLanguageId() === PLAINTEXT_LANGUAGE_ID &&
-                                extname$1(modelToRestore.target) !== PLAINTEXT_EXTENSION) {
-                                restoredModel.updateTextEditorModel(undefined, modelToRestore.languageId);
-                            }
-                        }))));
-                    }
-                })());
-                break;
-        }
-    }
-    get(resource) {
-        return this.mapResourceToModel.get(resource);
-    }
-    has(resource) {
-        return this.mapResourceToModel.has(resource);
-    }
-    async reload(model) {
-        await this.joinPendingResolves(model.resource);
-        if (model.isDirty() || model.isDisposed() || !this.has(model.resource)) {
-            return;
-        }
-        await this.doResolve(model, { reload: { async: false } });
+};
+BinaryEditorModel = ( (__decorate([
+    ( (__param(2, IFileService)))
+], BinaryEditorModel)));
+let FileEditorInput = class FileEditorInput extends AbstractTextResourceEditorInput {
+    get typeId() {
+        return FILE_EDITOR_INPUT_ID;
     }
-    async resolve(resource, options) {
-        const pendingResolve = this.joinPendingResolves(resource);
-        if (pendingResolve) {
-            await pendingResolve;
-        }
-        return this.doResolve(resource, options);
+    get editorId() {
+        return DEFAULT_EDITOR_ASSOCIATION.id;
     }
-    async doResolve(resourceOrModel, options) {
-        let model;
-        let resource;
-        if (URI.isUri(resourceOrModel)) {
-            resource = resourceOrModel;
-            model = this.get(resource);
+    get capabilities() {
+        let capabilities = 32 ;
+        if (this.model) {
+            if (this.model.isReadonly()) {
+                capabilities |= 2 ;
+            }
         }
         else {
-            resource = resourceOrModel.resource;
-            model = resourceOrModel;
-        }
-        let modelResolve;
-        let didCreateModel = false;
-        if (model) {
-            if (options?.contents) {
-                modelResolve = model.resolve(options);
-            }
-            else if (options?.reload) {
-                if (options.reload.async) {
-                    modelResolve = Promise.resolve();
-                    (async () => {
-                        try {
-                            await model.resolve(options);
-                        }
-                        catch (error) {
-                            onUnexpectedError(error);
-                        }
-                    })();
-                }
-                else {
-                    modelResolve = model.resolve(options);
+            if (this.fileService.hasProvider(this.resource)) {
+                if (this.fileService.hasCapability(this.resource, 2048 )) {
+                    capabilities |= 2 ;
                 }
             }
             else {
-                modelResolve = Promise.resolve();
+                capabilities |= 4 ;
             }
         }
-        else {
-            didCreateModel = true;
-            const newModel = model = this.instantiationService.createInstance(TextFileEditorModel, resource, options ? options.encoding : undefined, options ? options.languageId : undefined);
-            modelResolve = model.resolve(options);
-            this.registerModel(newModel);
+        if (!((capabilities & 2) )) {
+            capabilities |= 128 ;
         }
-        this.mapResourceToPendingModelResolvers.set(resource, modelResolve);
-        this.add(resource, model);
-        if (didCreateModel) {
-            this._onDidCreate.fire(model);
-            if (model.isDirty()) {
-                this._onDidChangeDirty.fire(model);
-            }
+        return capabilities;
+    }
+    constructor(resource, preferredResource, preferredName, preferredDescription, preferredEncoding, preferredLanguageId, preferredContents, instantiationService, textFileService, textModelResolverService, labelService, fileService, filesConfigurationService, editorService, pathService, textResourceConfigurationService) {
+        super(resource, preferredResource, editorService, textFileService, labelService, fileService);
+        this.instantiationService = instantiationService;
+        this.textModelResolverService = textModelResolverService;
+        this.filesConfigurationService = filesConfigurationService;
+        this.pathService = pathService;
+        this.textResourceConfigurationService = textResourceConfigurationService;
+        this.forceOpenAs = 0 ;
+        this.model = undefined;
+        this.cachedTextFileModelReference = undefined;
+        this.modelListeners = this._register(( (new DisposableStore())));
+        this.model = this.textFileService.files.get(resource);
+        if (preferredName) {
+            this.setPreferredName(preferredName);
         }
-        try {
-            await modelResolve;
+        if (preferredDescription) {
+            this.setPreferredDescription(preferredDescription);
         }
-        catch (error) {
-            if (didCreateModel) {
-                model.dispose();
-            }
-            throw error;
+        if (preferredEncoding) {
+            this.setPreferredEncoding(preferredEncoding);
         }
-        finally {
-            this.mapResourceToPendingModelResolvers.delete(resource);
+        if (preferredLanguageId) {
+            this.setPreferredLanguageId(preferredLanguageId);
         }
-        if (options?.languageId) {
-            model.setLanguageId(options.languageId);
+        if (typeof preferredContents === 'string') {
+            this.setPreferredContents(preferredContents);
         }
-        if (didCreateModel && model.isDirty()) {
-            this._onDidChangeDirty.fire(model);
+        this._register(this.textFileService.files.onDidCreate(model => this.onDidCreateTextFileModel(model)));
+        if (this.model) {
+            this.registerModelListeners(this.model);
         }
-        return model;
     }
-    joinPendingResolves(resource) {
-        const pendingModelResolve = this.mapResourceToPendingModelResolvers.get(resource);
-        if (!pendingModelResolve) {
-            return;
+    onDidCreateTextFileModel(model) {
+        if (isEqual(model.resource, this.resource)) {
+            this.model = model;
+            this.registerModelListeners(model);
         }
-        return this.doJoinPendingResolves(resource);
     }
-    async doJoinPendingResolves(resource) {
-        let currentModelCopyResolve;
-        while (this.mapResourceToPendingModelResolvers.has(resource)) {
-            const nextPendingModelResolve = this.mapResourceToPendingModelResolvers.get(resource);
-            if (nextPendingModelResolve === currentModelCopyResolve) {
-                return;
-            }
-            currentModelCopyResolve = nextPendingModelResolve;
-            try {
-                await nextPendingModelResolve;
-            }
-            catch (error) {
-            }
-        }
+    registerModelListeners(model) {
+        this.modelListeners.clear();
+        this.modelListeners.add(model.onDidChangeDirty(() => this._onDidChangeDirty.fire()));
+        this.modelListeners.add(model.onDidChangeReadonly(() => this._onDidChangeCapabilities.fire()));
+        this.modelListeners.add(model.onDidSaveError(() => this._onDidChangeDirty.fire()));
+        this.modelListeners.add(Event.once(model.onWillDispose)(() => {
+            this.modelListeners.clear();
+            this.model = undefined;
+        }));
     }
-    registerModel(model) {
-        const modelListeners = ( (new DisposableStore()));
-        modelListeners.add(model.onDidResolve(reason => this._onDidResolve.fire({ model, reason })));
-        modelListeners.add(model.onDidChangeDirty(() => this._onDidChangeDirty.fire(model)));
-        modelListeners.add(model.onDidChangeReadonly(() => this._onDidChangeReadonly.fire(model)));
-        modelListeners.add(model.onDidChangeOrphaned(() => this._onDidChangeOrphaned.fire(model)));
-        modelListeners.add(model.onDidSaveError(() => this._onDidSaveError.fire(model)));
-        modelListeners.add(model.onDidSave(e => this._onDidSave.fire({ model, ...e })));
-        modelListeners.add(model.onDidRevert(() => this._onDidRevert.fire(model)));
-        modelListeners.add(model.onDidChangeEncoding(() => this._onDidChangeEncoding.fire(model)));
-        this.mapResourceToModelListeners.set(model.resource, modelListeners);
+    getName() {
+        return this.preferredName || super.getName();
     }
-    add(resource, model) {
-        const knownModel = this.mapResourceToModel.get(resource);
-        if (knownModel === model) {
+    setPreferredName(name) {
+        if (!this.allowLabelOverride()) {
             return;
         }
-        const disposeListener = this.mapResourceToDisposeListener.get(resource);
-        disposeListener?.dispose();
-        this.mapResourceToModel.set(resource, model);
-        this.mapResourceToDisposeListener.set(resource, model.onWillDispose(() => this.remove(resource)));
-    }
-    remove(resource) {
-        const removed = this.mapResourceToModel.delete(resource);
-        const disposeListener = this.mapResourceToDisposeListener.get(resource);
-        if (disposeListener) {
-            dispose(disposeListener);
-            this.mapResourceToDisposeListener.delete(resource);
-        }
-        const modelListener = this.mapResourceToModelListeners.get(resource);
-        if (modelListener) {
-            dispose(modelListener);
-            this.mapResourceToModelListeners.delete(resource);
-        }
-        if (removed) {
-            this._onDidRemove.fire(resource);
+        if (this.preferredName !== name) {
+            this.preferredName = name;
+            this._onDidChangeLabel.fire();
         }
     }
-    addSaveParticipant(participant) {
-        return this.saveParticipants.addSaveParticipant(participant);
+    allowLabelOverride() {
+        return this.resource.scheme !== this.pathService.defaultUriScheme &&
+            this.resource.scheme !== Schemas.vscodeUserData &&
+            this.resource.scheme !== Schemas.file &&
+            this.resource.scheme !== Schemas.vscodeRemote;
     }
-    runSaveParticipants(model, context, token) {
-        return this.saveParticipants.participate(model, context, token);
+    getPreferredName() {
+        return this.preferredName;
     }
-    canDispose(model) {
-        if (model.isDisposed() ||
-            (!this.mapResourceToPendingModelResolvers.has(model.resource) && !model.isDirty())) {
-            return true;
-        }
-        return this.doCanDispose(model);
+    getDescription(verbosity) {
+        return this.preferredDescription || super.getDescription(verbosity);
     }
-    async doCanDispose(model) {
-        const pendingResolve = this.joinPendingResolves(model.resource);
-        if (pendingResolve) {
-            await pendingResolve;
-            return this.canDispose(model);
+    setPreferredDescription(description) {
+        if (!this.allowLabelOverride()) {
+            return;
         }
-        if (model.isDirty()) {
-            await Event.toPromise(model.onDidChangeDirty);
-            return this.canDispose(model);
+        if (this.preferredDescription !== description) {
+            this.preferredDescription = description;
+            this._onDidChangeLabel.fire();
         }
-        return true;
     }
-    dispose() {
-        super.dispose();
-        this.mapResourceToModel.clear();
-        this.mapResourceToPendingModelResolvers.clear();
-        dispose(( (this.mapResourceToDisposeListener.values())));
-        this.mapResourceToDisposeListener.clear();
-        dispose(( (this.mapResourceToModelListeners.values())));
-        this.mapResourceToModelListeners.clear();
-    }
-};
-TextFileEditorModelManager = ( (__decorate([
-    ( (__param(0, IInstantiationService))),
-    ( (__param(1, IFileService))),
-    ( (__param(2, INotificationService))),
-    ( (__param(3, IWorkingCopyFileService))),
-    ( (__param(4, IUriIdentityService)))
-], TextFileEditorModelManager)));
-let AbstractTextFileService = class AbstractTextFileService extends Disposable {
-    constructor(fileService, untitledTextEditorService, lifecycleService, instantiationService, modelService, environmentService, dialogService, fileDialogService, textResourceConfigurationService, filesConfigurationService, codeEditorService, pathService, workingCopyFileService, uriIdentityService, languageService, logService, elevatedFileService, decorationsService) {
-        super();
-        this.fileService = fileService;
-        this.untitledTextEditorService = untitledTextEditorService;
-        this.lifecycleService = lifecycleService;
-        this.instantiationService = instantiationService;
-        this.modelService = modelService;
-        this.environmentService = environmentService;
-        this.dialogService = dialogService;
-        this.fileDialogService = fileDialogService;
-        this.textResourceConfigurationService = textResourceConfigurationService;
-        this.filesConfigurationService = filesConfigurationService;
-        this.codeEditorService = codeEditorService;
-        this.pathService = pathService;
-        this.workingCopyFileService = workingCopyFileService;
-        this.uriIdentityService = uriIdentityService;
-        this.languageService = languageService;
-        this.logService = logService;
-        this.elevatedFileService = elevatedFileService;
-        this.decorationsService = decorationsService;
-        this.files = this._register(this.instantiationService.createInstance(TextFileEditorModelManager));
-        this.untitled = this.untitledTextEditorService;
-        this.provideDecorations();
-    }
-    provideDecorations() {
-        this.decorationsService.registerDecorationsProvider(new (class extends Disposable {
-            constructor(files) {
-                super();
-                this.files = files;
-                this.label = ( (localize('textFileModelDecorations', "Text File Model Decorations")));
-                this._onDidChange = this._register(( (new Emitter())));
-                this.onDidChange = this._onDidChange.event;
-                this.registerListeners();
-            }
-            registerListeners() {
-                this._register(this.files.onDidResolve(({ model }) => {
-                    if (model.isReadonly() || model.hasState(4 )) {
-                        this._onDidChange.fire([model.resource]);
-                    }
-                }));
-                this._register(this.files.onDidRemove(modelUri => this._onDidChange.fire([modelUri])));
-                this._register(this.files.onDidChangeReadonly(model => this._onDidChange.fire([model.resource])));
-                this._register(this.files.onDidChangeOrphaned(model => this._onDidChange.fire([model.resource])));
-            }
-            provideDecorations(uri) {
-                const model = this.files.get(uri);
-                if (!model || model.isDisposed()) {
-                    return undefined;
-                }
-                const isReadonly = model.isReadonly();
-                const isOrphaned = model.hasState(4 );
-                if (isReadonly && isOrphaned) {
-                    return {
-                        color: listErrorForeground,
-                        letter: Codicon.lockSmall,
-                        strikethrough: true,
-                        tooltip: ( (localize('readonlyAndDeleted', "Deleted, Read Only"))),
-                    };
-                }
-                else if (isReadonly) {
-                    return {
-                        letter: Codicon.lockSmall,
-                        tooltip: ( (localize('readonly', "Read Only"))),
-                    };
-                }
-                else if (isOrphaned) {
-                    return {
-                        color: listErrorForeground,
-                        strikethrough: true,
-                        tooltip: ( (localize('deleted', "Deleted"))),
-                    };
-                }
-                return undefined;
-            }
-        })(this.files));
+    getPreferredDescription() {
+        return this.preferredDescription;
     }
-    get encoding() {
-        if (!this._encoding) {
-            this._encoding = this._register(this.instantiationService.createInstance(EncodingOracle));
+    getEncoding() {
+        if (this.model) {
+            return this.model.getEncoding();
         }
-        return this._encoding;
+        return this.preferredEncoding;
     }
-    async read(resource, options) {
-        const [bufferStream, decoder] = await this.doRead(resource, {
-            ...options,
-            preferUnbuffered: true
-        });
-        return {
-            ...bufferStream,
-            encoding: decoder.detected.encoding || UTF8,
-            value: await consumeStream(decoder.stream, strings => strings.join(''))
-        };
+    getPreferredEncoding() {
+        return this.preferredEncoding;
     }
-    async readStream(resource, options) {
-        const [bufferStream, decoder] = await this.doRead(resource, options);
-        return {
-            ...bufferStream,
-            encoding: decoder.detected.encoding || UTF8,
-            value: await createTextBufferFactoryFromStream(decoder.stream)
-        };
+    async setEncoding(encoding, mode) {
+        this.setPreferredEncoding(encoding);
+        return this.model?.setEncoding(encoding, mode);
     }
-    async doRead(resource, options) {
-        const cts = ( (new CancellationTokenSource()));
-        let bufferStream;
-        if (options?.preferUnbuffered) {
-            const content = await this.fileService.readFile(resource, options, cts.token);
-            bufferStream = {
-                ...content,
-                value: bufferToStream(content.value)
-            };
-        }
-        else {
-            bufferStream = await this.fileService.readFileStream(resource, options, cts.token);
-        }
-        try {
-            const decoder = await this.doGetDecodedStream(resource, bufferStream.value, options);
-            return [bufferStream, decoder];
-        }
-        catch (error) {
-            cts.dispose(true);
-            if (error.decodeStreamErrorKind === 1 ) {
-                throw new TextFileOperationError(localize('fileBinaryError', "File seems to be binary and cannot be opened as text"), 0 , options);
-            }
-            else {
-                throw error;
-            }
+    setPreferredEncoding(encoding) {
+        this.preferredEncoding = encoding;
+        this.setForceOpenAsText();
+    }
+    getLanguageId() {
+        if (this.model) {
+            return this.model.getLanguageId();
         }
+        return this.preferredLanguageId;
     }
-    async create(operations, undoInfo) {
-        const operationsWithContents = await Promise.all(( (operations.map(async (operation) => {
-            const contents = await this.getEncodedReadable(operation.resource, operation.value);
-            return {
-                resource: operation.resource,
-                contents,
-                overwrite: operation.options?.overwrite
-            };
-        }))));
-        return this.workingCopyFileService.create(operationsWithContents, CancellationToken.None, undoInfo);
+    getPreferredLanguageId() {
+        return this.preferredLanguageId;
     }
-    async write(resource, value, options) {
-        const readable = await this.getEncodedReadable(resource, value, options);
-        if (options?.writeElevated && this.elevatedFileService.isSupported(resource)) {
-            return this.elevatedFileService.writeFileElevated(resource, readable, options);
-        }
-        return this.fileService.writeFile(resource, readable, options);
+    setLanguageId(languageId, source) {
+        this.setPreferredLanguageId(languageId);
+        this.model?.setLanguageId(languageId, source);
     }
-    async getEncodedReadable(resource, value, options) {
-        const { encoding, addBOM } = await this.encoding.getWriteEncoding(resource, options);
-        if (encoding === UTF8 && !addBOM) {
-            return typeof value === 'undefined'
-                ? undefined
-                : toBufferOrReadable(value);
-        }
-        value = value || '';
-        const snapshot = typeof value === 'string' ? stringToSnapshot(value) : value;
-        return toEncodeReadable(snapshot, encoding, { addBOM });
+    setPreferredLanguageId(languageId) {
+        this.preferredLanguageId = languageId;
+        this.setForceOpenAsText();
     }
-    async getDecodedStream(resource, value, options) {
-        return (await this.doGetDecodedStream(resource, value, options)).stream;
+    setPreferredContents(contents) {
+        this.preferredContents = contents;
+        this.setForceOpenAsText();
     }
-    doGetDecodedStream(resource, stream, options) {
-        return toDecodeStream(stream, {
-            acceptTextOnly: options?.acceptTextOnly ?? false,
-            guessEncoding: options?.autoGuessEncoding || this.textResourceConfigurationService.getValue(resource, 'files.autoGuessEncoding'),
-            overwriteEncoding: async (detectedEncoding) => {
-                const { encoding } = await this.encoding.getPreferredReadEncoding(resource, options, withNullAsUndefined(detectedEncoding));
-                return encoding;
-            }
-        });
+    setForceOpenAsText() {
+        this.forceOpenAs = 1 ;
     }
-    async save(resource, options) {
-        if (resource.scheme === Schemas.untitled) {
-            const model = this.untitled.get(resource);
-            if (model) {
-                let targetUri;
-                if (model.hasAssociatedFilePath) {
-                    targetUri = await this.suggestSavePath(resource);
-                }
-                else {
-                    targetUri = await this.fileDialogService.pickFileToSave(await this.suggestSavePath(resource), options?.availableFileSystems);
-                }
-                if (targetUri) {
-                    return this.saveAs(resource, targetUri, options);
-                }
-            }
+    setForceOpenAsBinary() {
+        this.forceOpenAs = 2 ;
+    }
+    isDirty() {
+        return !!(this.model?.isDirty());
+    }
+    isSaving() {
+        if (this.model?.hasState(0 ) || this.model?.hasState(3 ) || this.model?.hasState(5 )) {
+            return false;
         }
-        else {
-            const model = this.files.get(resource);
-            if (model) {
-                return (await model.save(options)) ? resource : undefined;
-            }
+        if (this.filesConfigurationService.getAutoSaveMode() === 1 ) {
+            return true;
         }
-        return undefined;
+        return super.isSaving();
     }
-    async saveAs(source, target, options) {
-        if (!target) {
-            target = await this.fileDialogService.pickFileToSave(await this.suggestSavePath(options?.suggestedTarget ?? source), options?.availableFileSystems);
+    prefersEditorPane(editorPanes) {
+        if (this.forceOpenAs === 2 ) {
+            return editorPanes.find(editorPane => editorPane.typeId === BINARY_FILE_EDITOR_ID);
         }
-        if (!target) {
-            return;
+        return editorPanes.find(editorPane => editorPane.typeId === TEXT_FILE_EDITOR_ID);
+    }
+    resolve(options) {
+        if (this.forceOpenAs === 2 ) {
+            return this.doResolveAsBinary();
         }
-        if (isEqual(source, target)) {
-            return this.save(source, { ...options, force: true  });
+        return this.doResolveAsText(options);
+    }
+    async doResolveAsText(options) {
+        try {
+            const preferredContents = this.preferredContents;
+            this.preferredContents = undefined;
+            await this.textFileService.files.resolve(this.resource, {
+                languageId: this.preferredLanguageId,
+                encoding: this.preferredEncoding,
+                contents: typeof preferredContents === 'string' ? createTextBufferFactory(preferredContents) : undefined,
+                reload: { async: true },
+                allowBinary: this.forceOpenAs === 1 ,
+                reason: 1 ,
+                limits: this.ensureLimits(options)
+            });
+            if (!this.cachedTextFileModelReference) {
+                this.cachedTextFileModelReference = await this.textModelResolverService.createModelReference(this.resource);
+            }
+            const model = this.cachedTextFileModelReference.object;
+            if (this.isDisposed()) {
+                this.disposeModelReference();
+            }
+            return model;
         }
-        if (this.fileService.hasProvider(source) && this.uriIdentityService.extUri.isEqual(source, target) && (await this.fileService.exists(source))) {
-            await this.workingCopyFileService.move([{ file: { source, target } }], CancellationToken.None);
-            const success = await this.save(source, options);
-            if (!success) {
-                await this.save(target, options);
+        catch (error) {
+            if (error.textFileOperationResult === 0 ) {
+                return this.doResolveAsBinary();
             }
-            return target;
+            throw error;
         }
-        return this.doSaveAs(source, target, options);
     }
-    async doSaveAs(source, target, options) {
-        let success = false;
-        const textFileModel = this.files.get(source);
-        if (textFileModel?.isResolved()) {
-            success = await this.doSaveAsTextFile(textFileModel, source, target, options);
-        }
-        else if (this.fileService.hasProvider(source)) {
-            await this.fileService.copy(source, target, true);
-            success = true;
+    ensureLimits(options) {
+        if (options?.limits) {
+            return options.limits;
         }
-        else {
-            const textModel = this.modelService.getModel(source);
-            if (textModel) {
-                success = await this.doSaveAsTextFile(textModel, source, target, options);
-            }
+        const defaultSizeLimit = getLargeFileConfirmationLimit(this.resource);
+        let configuredSizeLimit = undefined;
+        const configuredSizeLimitMb = this.textResourceConfigurationService.getValue(this.resource, 'workbench.editorLargeFileConfirmation');
+        if (typeof configuredSizeLimitMb === 'number') {
+            configuredSizeLimit = configuredSizeLimitMb * ByteSize.MB;
         }
-        if (!success) {
-            return undefined;
+        return {
+            size: Math.max(defaultSizeLimit, configuredSizeLimit ?? defaultSizeLimit)
+        };
+    }
+    async doResolveAsBinary() {
+        const model = this.instantiationService.createInstance(BinaryEditorModel, this.preferredResource, this.getName());
+        await model.resolve();
+        return model;
+    }
+    isResolved() {
+        return !!this.model;
+    }
+    async rename(group, target) {
+        return {
+            editor: {
+                resource: target,
+                encoding: this.getEncoding(),
+                options: {
+                    viewState: findViewStateForEditor(this, group, this.editorService)
+                }
+            }
+        };
+    }
+    toUntyped(options) {
+        const untypedInput = {
+            resource: this.preferredResource,
+            forceFile: true,
+            options: {
+                override: this.editorId
+            }
+        };
+        if (typeof options?.preserveViewState === 'number') {
+            untypedInput.encoding = this.getEncoding();
+            untypedInput.languageId = this.getLanguageId();
+            untypedInput.contents = (() => {
+                const model = this.textFileService.files.get(this.resource);
+                if (model?.isDirty()) {
+                    return model.textEditorModel.getValue();
+                }
+                return undefined;
+            })();
+            untypedInput.options = {
+                ...untypedInput.options,
+                viewState: findViewStateForEditor(this, options.preserveViewState, this.editorService)
+            };
         }
-        try {
-            await this.revert(source);
+        return untypedInput;
+    }
+    matches(otherInput) {
+        if (this === otherInput) {
+            return true;
         }
-        catch (error) {
-            this.logService.error(error);
+        if (otherInput instanceof FileEditorInput) {
+            return isEqual(otherInput.resource, this.resource);
         }
-        return target;
-    }
-    async doSaveAsTextFile(sourceModel, source, target, options) {
-        let sourceModelEncoding = undefined;
-        const sourceModelWithEncodingSupport = sourceModel;
-        if (typeof sourceModelWithEncodingSupport.getEncoding === 'function') {
-            sourceModelEncoding = sourceModelWithEncodingSupport.getEncoding();
+        if (isResourceEditorInput(otherInput)) {
+            return super.matches(otherInput);
         }
-        let targetExists = false;
-        let targetModel = this.files.get(target);
-        if (targetModel?.isResolved()) {
-            targetExists = true;
+        return false;
+    }
+    dispose() {
+        this.model = undefined;
+        this.disposeModelReference();
+        super.dispose();
+    }
+    disposeModelReference() {
+        dispose(this.cachedTextFileModelReference);
+        this.cachedTextFileModelReference = undefined;
+    }
+};
+FileEditorInput = ( (__decorate([
+    ( (__param(7, IInstantiationService))),
+    ( (__param(8, ITextFileService))),
+    ( (__param(9, ITextModelService))),
+    ( (__param(10, ILabelService))),
+    ( (__param(11, IFileService))),
+    ( (__param(12, IFilesConfigurationService))),
+    ( (__param(13, IEditorService))),
+    ( (__param(14, IPathService))),
+    ( (__param(15, ITextResourceConfigurationService)))
+], FileEditorInput)));
+class ExplorerFileNestingTrie {
+    constructor(config) {
+        this.root = ( (new PreTrie()));
+        for (const [parentPattern, childPatterns] of config) {
+            for (const childPattern of childPatterns) {
+                this.root.add(parentPattern, childPattern);
+            }
+        }
+    }
+    toString() {
+        return (
+             (this.root.toString())
+        );
+    }
+    getAttributes(filename, dirname) {
+        const lastDot = filename.lastIndexOf('.');
+        if (lastDot < 1) {
+            return {
+                dirname,
+                basename: filename,
+                extname: ''
+            };
         }
         else {
-            targetExists = await this.fileService.exists(target);
-            if (!targetExists) {
-                await this.create([{ resource: target, value: '' }]);
+            return {
+                dirname,
+                basename: filename.substring(0, lastDot),
+                extname: filename.substring(lastDot + 1)
+            };
+        }
+    }
+    nest(files, dirname) {
+        const parentFinder = ( (new PreTrie()));
+        for (const potentialParent of files) {
+            const attributes = this.getAttributes(potentialParent, dirname);
+            const children = this.root.get(potentialParent, attributes);
+            for (const child of children) {
+                parentFinder.add(child, potentialParent);
             }
-            try {
-                targetModel = await this.files.resolve(target, { encoding: sourceModelEncoding });
+        }
+        const findAllRootAncestors = (file, seen = ( (new Set()))) => {
+            if (seen.has(file)) {
+                return [];
             }
-            catch (error) {
-                if (targetExists) {
-                    if (error.textFileOperationResult === 0  ||
-                        error.fileOperationResult === 7 ) {
-                        await this.fileService.del(target);
-                        return this.doSaveAsTextFile(sourceModel, source, target, options);
-                    }
+            seen.add(file);
+            const attributes = this.getAttributes(file, dirname);
+            const ancestors = parentFinder.get(file, attributes);
+            if (ancestors.length === 0) {
+                return [file];
+            }
+            if (ancestors.length === 1 && ancestors[0] === file) {
+                return [file];
+            }
+            return ancestors.flatMap(a => findAllRootAncestors(a, seen));
+        };
+        const result = ( (new Map()));
+        for (const file of files) {
+            let ancestors = findAllRootAncestors(file);
+            if (ancestors.length === 0) {
+                ancestors = [file];
+            }
+            for (const ancestor of ancestors) {
+                let existing = result.get(ancestor);
+                if (!existing) {
+                    result.set(ancestor, existing = ( (new Set())));
+                }
+                if (file !== ancestor) {
+                    existing.add(file);
                 }
-                throw error;
             }
         }
-        let write;
-        if (sourceModel instanceof UntitledTextEditorModel && sourceModel.hasAssociatedFilePath && targetExists && this.uriIdentityService.extUri.isEqual(target, toLocalResource(sourceModel.resource, this.environmentService.remoteAuthority, this.pathService.defaultUriScheme))) {
-            write = await this.confirmOverwrite(target);
+        return result;
+    }
+}
+class PreTrie {
+    constructor() {
+        this.value = ( (new SufTrie()));
+        this.map = ( (new Map()));
+    }
+    add(key, value) {
+        if (key === '') {
+            this.value.add(key, value);
+        }
+        else if (key[0] === '*') {
+            this.value.add(key, value);
         }
         else {
-            write = true;
+            const head = key[0];
+            const rest = key.slice(1);
+            let existing = this.map.get(head);
+            if (!existing) {
+                this.map.set(head, existing = ( (new PreTrie())));
+            }
+            existing.add(rest, value);
         }
-        if (!write) {
-            return false;
+    }
+    get(key, attributes) {
+        const results = [];
+        results.push(...this.value.get(key, attributes));
+        const head = key[0];
+        const rest = key.slice(1);
+        const existing = this.map.get(head);
+        if (existing) {
+            results.push(...existing.get(rest, attributes));
         }
-        let sourceTextModel = undefined;
-        if (sourceModel instanceof BaseTextEditorModel) {
-            if (sourceModel.isResolved()) {
-                sourceTextModel = sourceModel.textEditorModel;
-            }
+        return results;
+    }
+    toString(indentation = '') {
+        const lines = [];
+        if (this.value.hasItems) {
+            lines.push('* => \n' + ( (this.value.toString(indentation + '  '))));
+        }
+        return ( (lines.map(l => indentation + l))).join('\n');
+    }
+}
+class SufTrie {
+    constructor() {
+        this.star = [];
+        this.epsilon = [];
+        this.map = ( (new Map()));
+        this.hasItems = false;
+    }
+    add(key, value) {
+        this.hasItems = true;
+        if (key === '*') {
+            this.star.push(( (new SubstitutionString(value))));
+        }
+        else if (key === '') {
+            this.epsilon.push(( (new SubstitutionString(value))));
         }
         else {
-            sourceTextModel = sourceModel;
-        }
-        let targetTextModel = undefined;
-        if (targetModel.isResolved()) {
-            targetTextModel = targetModel.textEditorModel;
-        }
-        if (sourceTextModel && targetTextModel) {
-            targetModel.updatePreferredEncoding(sourceModelEncoding);
-            this.modelService.updateModel(targetTextModel, createTextBufferFactoryFromSnapshot(sourceTextModel.createSnapshot()));
-            const sourceLanguageId = sourceTextModel.getLanguageId();
-            const targetLanguageId = targetTextModel.getLanguageId();
-            if (sourceLanguageId !== PLAINTEXT_LANGUAGE_ID && targetLanguageId === PLAINTEXT_LANGUAGE_ID) {
-                targetTextModel.setMode(sourceLanguageId);
-            }
-            const sourceTransientProperties = this.codeEditorService.getTransientModelProperties(sourceTextModel);
-            if (sourceTransientProperties) {
-                for (const [key, value] of sourceTransientProperties) {
-                    this.codeEditorService.setTransientModelProperty(targetTextModel, key, value);
+            const tail = key[key.length - 1];
+            const rest = key.slice(0, key.length - 1);
+            if (tail === '*') {
+                throw Error('Unexpected star in SufTrie key: ' + key);
+            }
+            else {
+                let existing = this.map.get(tail);
+                if (!existing) {
+                    this.map.set(tail, existing = ( (new SufTrie())));
                 }
+                existing.add(rest, value);
             }
         }
-        if (!options?.source) {
-            options = {
-                ...options,
-                source: targetExists ? AbstractTextFileService.TEXTFILE_SAVE_REPLACE_SOURCE : AbstractTextFileService.TEXTFILE_SAVE_CREATE_SOURCE
-            };
+    }
+    get(key, attributes) {
+        const results = [];
+        if (key === '') {
+            results.push(...( (this.epsilon.map(ss => ss.substitute(attributes)))));
+        }
+        if (this.star.length) {
+            results.push(...( (this.star.map(ss => ss.substitute(attributes, key)))));
+        }
+        const tail = key[key.length - 1];
+        const rest = key.slice(0, key.length - 1);
+        const existing = this.map.get(tail);
+        if (existing) {
+            results.push(...existing.get(rest, attributes));
         }
-        return targetModel.save(options);
+        return results;
     }
-    async confirmOverwrite(resource) {
-        const { confirmed } = await this.dialogService.confirm({
-            type: 'warning',
-            message: ( (localize(
-                'confirmOverwrite',
-                "'{0}' already exists. Do you want to replace it?",
-                basename(resource)
-            ))),
-            detail: ( (localize(
-                'irreversible',
-                "A file or folder with the name '{0}' already exists in the folder '{1}'. Replacing it will overwrite its current contents.",
-                basename(resource),
-                basename(dirname(resource))
-            ))),
-            primaryButton: ( (localize(
-                { key: 'replaceButtonLabel', comment: ['&& denotes a mnemonic'] },
-                "&&Replace"
-            ))),
+    toString(indentation = '') {
+        const lines = [];
+        if (this.star.length) {
+            lines.push('* => ' + this.star.join('; '));
+        }
+        if (this.epsilon.length) {
+            lines.push('ε => ' + this.epsilon.join('; '));
+        }
+        return ( (lines.map(l => indentation + l))).join('\n');
+    }
+}
+const substitutionStringTokenizer = /\$[({](capture|basename|dirname|extname)[)}]/g;
+class SubstitutionString {
+    constructor(pattern) {
+        this.tokens = [];
+        substitutionStringTokenizer.lastIndex = 0;
+        let token;
+        let lastIndex = 0;
+        while (token = substitutionStringTokenizer.exec(pattern)) {
+            const prefix = pattern.slice(lastIndex, token.index);
+            this.tokens.push(prefix);
+            const type = token[1];
+            switch (type) {
+                case "basename" :
+                case "dirname" :
+                case "extname" :
+                case "capture" :
+                    this.tokens.push({ capture: type });
+                    break;
+                default: throw Error('unknown substitution type: ' + type);
+            }
+            lastIndex = token.index + token[0].length;
+        }
+        if (lastIndex !== pattern.length) {
+            const suffix = pattern.slice(lastIndex, pattern.length);
+            this.tokens.push(suffix);
+        }
+    }
+    substitute(attributes, capture) {
+        return ( (this.tokens.map(t => {
+            if (typeof t === 'string') {
+                return t;
+            }
+            switch (t.capture) {
+                case "basename" : return attributes.basename;
+                case "dirname" : return attributes.dirname;
+                case "extname" : return attributes.extname;
+                case "capture" : return capture || '';
+            }
+        }))).join('');
+    }
+}
+class ExplorerModel {
+    constructor(contextService, uriIdentityService, fileService, configService) {
+        this.contextService = contextService;
+        this.uriIdentityService = uriIdentityService;
+        this._onDidChangeRoots = ( (new Emitter()));
+        const setRoots = () => this._roots = ( (this.contextService.getWorkspace().folders
+            .map(folder => ( (new ExplorerItem(
+            folder.uri,
+            fileService,
+            configService,
+            undefined,
+            true,
+            false,
+            false,
+            folder.name
+        ))))));
+        setRoots();
+        this._listener = this.contextService.onDidChangeWorkspaceFolders(() => {
+            setRoots();
+            this._onDidChangeRoots.fire();
         });
-        return confirmed;
-    }
-    async suggestSavePath(resource) {
-        if (this.fileService.hasProvider(resource)) {
-            return resource;
-        }
-        const remoteAuthority = this.environmentService.remoteAuthority;
-        const defaultFilePath = await this.fileDialogService.defaultFilePath();
-        let suggestedFilename = undefined;
-        if (resource.scheme === Schemas.untitled) {
-            const model = this.untitled.get(resource);
-            if (model) {
-                if (model.hasAssociatedFilePath) {
-                    return toLocalResource(resource, remoteAuthority, this.pathService.defaultUriScheme);
+    }
+    get roots() {
+        return this._roots;
+    }
+    get onDidChangeRoots() {
+        return this._onDidChangeRoots.event;
+    }
+    findAll(resource) {
+        return coalesce(( (this.roots.map(root => root.find(resource)))));
+    }
+    findClosest(resource) {
+        const folder = this.contextService.getWorkspaceFolder(resource);
+        if (folder) {
+            const root = this.roots.find(r => this.uriIdentityService.extUri.isEqual(r.resource, folder.uri));
+            if (root) {
+                return root.find(resource);
+            }
+        }
+        return null;
+    }
+    dispose() {
+        dispose(this._listener);
+    }
+}
+class ExplorerItem {
+    constructor(resource, fileService, configService, _parent, _isDirectory, _isSymbolicLink, _readonly, _name = basenameOrAuthority(resource), _mtime, _unknown = false) {
+        this.resource = resource;
+        this.fileService = fileService;
+        this.configService = configService;
+        this._parent = _parent;
+        this._isDirectory = _isDirectory;
+        this._isSymbolicLink = _isSymbolicLink;
+        this._readonly = _readonly;
+        this._name = _name;
+        this._mtime = _mtime;
+        this._unknown = _unknown;
+        this.error = undefined;
+        this._isExcluded = false;
+        this._isDirectoryResolved = false;
+    }
+    get isExcluded() {
+        if (this._isExcluded) {
+            return true;
+        }
+        if (!this._parent) {
+            return false;
+        }
+        return this._parent.isExcluded;
+    }
+    set isExcluded(value) {
+        this._isExcluded = value;
+    }
+    hasChildren(filter) {
+        if (this.hasNests) {
+            return this.nestedChildren?.some(c => filter(c)) ?? false;
+        }
+        else {
+            return this.isDirectory;
+        }
+    }
+    get hasNests() {
+        return !!(this.nestedChildren?.length);
+    }
+    get isDirectoryResolved() {
+        return this._isDirectoryResolved;
+    }
+    get isSymbolicLink() {
+        return !!this._isSymbolicLink;
+    }
+    get isDirectory() {
+        return !!this._isDirectory;
+    }
+    get isReadonly() {
+        return this._readonly || this.fileService.hasCapability(this.resource, 2048 );
+    }
+    get mtime() {
+        return this._mtime;
+    }
+    get name() {
+        return this._name;
+    }
+    get isUnknown() {
+        return this._unknown;
+    }
+    get parent() {
+        return this._parent;
+    }
+    get root() {
+        if (!this._parent) {
+            return this;
+        }
+        return this._parent.root;
+    }
+    get children() {
+        return (
+             (new Map())
+        );
+    }
+    updateName(value) {
+        this._parent?.removeChild(this);
+        this._name = value;
+        this._parent?.addChild(this);
+    }
+    getId() {
+        return ( (this.root.resource.toString())) + '::' + ( (this.resource.toString()));
+    }
+    toString() {
+        return `ExplorerItem: ${this.name}`;
+    }
+    get isRoot() {
+        return this === this.root;
+    }
+    static create(fileService, configService, raw, parent, resolveTo) {
+        const stat = ( (new ExplorerItem(
+            raw.resource,
+            fileService,
+            configService,
+            parent,
+            raw.isDirectory,
+            raw.isSymbolicLink,
+            raw.readonly,
+            raw.name,
+            raw.mtime,
+            !raw.isFile && !raw.isDirectory
+        )));
+        if (stat.isDirectory) {
+            stat._isDirectoryResolved = !!raw.children || (!!resolveTo && resolveTo.some((r) => {
+                return isEqualOrParent(r, stat.resource);
+            }));
+            if (raw.children) {
+                for (let i = 0, len = raw.children.length; i < len; i++) {
+                    const child = ExplorerItem.create(fileService, configService, raw.children[i], stat, resolveTo);
+                    stat.addChild(child);
                 }
-                let nameCandidate;
-                if (await this.pathService.hasValidBasename(joinPath(defaultFilePath, model.name), model.name)) {
-                    nameCandidate = model.name;
+            }
+        }
+        return stat;
+    }
+    static mergeLocalWithDisk(disk, local) {
+        if (( (disk.resource.toString())) !== ( (local.resource.toString()))) {
+            return;
+        }
+        const mergingDirectories = disk.isDirectory || local.isDirectory;
+        if (mergingDirectories && local._isDirectoryResolved && !disk._isDirectoryResolved) {
+            return;
+        }
+        local.resource = disk.resource;
+        if (!local.isRoot) {
+            local.updateName(disk.name);
+        }
+        local._isDirectory = disk.isDirectory;
+        local._mtime = disk.mtime;
+        local._isDirectoryResolved = disk._isDirectoryResolved;
+        local._isSymbolicLink = disk.isSymbolicLink;
+        local.error = disk.error;
+        if (mergingDirectories && disk._isDirectoryResolved) {
+            const oldLocalChildren = ( (new ResourceMap()));
+            local.children.forEach(child => {
+                oldLocalChildren.set(child.resource, child);
+            });
+            local.children.clear();
+            disk.children.forEach(diskChild => {
+                const formerLocalChild = oldLocalChildren.get(diskChild.resource);
+                if (formerLocalChild) {
+                    ExplorerItem.mergeLocalWithDisk(diskChild, formerLocalChild);
+                    local.addChild(formerLocalChild);
+                    oldLocalChildren.delete(diskChild.resource);
                 }
                 else {
-                    nameCandidate = basename(resource);
-                }
-                const languageId = model.getLanguageId();
-                if (languageId && languageId !== PLAINTEXT_LANGUAGE_ID) {
-                    suggestedFilename = this.suggestFilename(languageId, nameCandidate);
+                    local.addChild(diskChild);
                 }
-                else {
-                    suggestedFilename = nameCandidate;
+            });
+            oldLocalChildren.forEach(oldChild => {
+                if (oldChild instanceof NewExplorerItem) {
+                    local.addChild(oldChild);
                 }
-            }
-        }
-        if (!suggestedFilename) {
-            suggestedFilename = basename(resource);
+            });
         }
-        return joinPath(defaultFilePath, suggestedFilename);
     }
-    suggestFilename(languageId, untitledName) {
-        const languageName = this.languageService.getLanguageName(languageId);
-        if (!languageName) {
-            return untitledName;
-        }
-        const untitledExtension = extname(untitledName);
-        const extensions = this.languageService.getExtensions(languageId);
-        if (extensions.includes(untitledExtension)) {
-            return untitledName;
+    addChild(child) {
+        child._parent = this;
+        child.updateResource(false);
+        this.children.set(this.getPlatformAwareName(child.name), child);
+    }
+    getChild(name) {
+        return this.children.get(this.getPlatformAwareName(name));
+    }
+    fetchChildren(sortOrder) {
+        const nestingConfig = this.configService.getValue({ resource: this.root.resource }).explorer.fileNesting;
+        if (nestingConfig.enabled && this.nestedChildren) {
+            return this.nestedChildren;
         }
-        const primaryExtension = firstOrDefault(extensions);
-        if (primaryExtension) {
-            if (untitledExtension) {
-                return `${untitledName.substring(0, untitledName.indexOf(untitledExtension))}${primaryExtension}`;
+        return (async () => {
+            if (!this._isDirectoryResolved) {
+                const resolveMetadata = sortOrder === "modified" ;
+                this.error = undefined;
+                try {
+                    const stat = await this.fileService.resolve(this.resource, { resolveSingleChildDescendants: true, resolveMetadata });
+                    const resolved = ExplorerItem.create(this.fileService, this.configService, stat, this);
+                    ExplorerItem.mergeLocalWithDisk(resolved, this);
+                }
+                catch (e) {
+                    this.error = e;
+                    throw e;
+                }
+                this._isDirectoryResolved = true;
+            }
+            const items = [];
+            if (nestingConfig.enabled) {
+                const fileChildren = [];
+                const dirChildren = [];
+                for (const child of this.children.entries()) {
+                    child[1].nestedParent = undefined;
+                    if (child[1].isDirectory) {
+                        dirChildren.push(child);
+                    }
+                    else {
+                        fileChildren.push(child);
+                    }
+                }
+                const nested = this.fileNester.nest(( (fileChildren.map(([name]) => name))), this.getPlatformAwareName(this.name));
+                for (const [fileEntryName, fileEntryItem] of fileChildren) {
+                    const nestedItems = nested.get(fileEntryName);
+                    if (nestedItems !== undefined) {
+                        fileEntryItem.nestedChildren = [];
+                        for (const name of ( (nestedItems.keys()))) {
+                            const child = assertIsDefined(this.children.get(name));
+                            fileEntryItem.nestedChildren.push(child);
+                            child.nestedParent = fileEntryItem;
+                        }
+                        items.push(fileEntryItem);
+                    }
+                    else {
+                        fileEntryItem.nestedChildren = undefined;
+                    }
+                }
+                for (const [_, dirEntryItem] of ( (dirChildren.values()))) {
+                    items.push(dirEntryItem);
+                }
+            }
+            else {
+                this.children.forEach(child => {
+                    items.push(child);
+                });
+            }
+            return items;
+        })();
+    }
+    get fileNester() {
+        if (!this.root._fileNester) {
+            const nestingConfig = this.configService.getValue({ resource: this.root.resource }).explorer.fileNesting;
+            const patterns = ( (Object.entries(nestingConfig.patterns)
+                .filter(entry => typeof (entry[0]) === 'string' && typeof (entry[1]) === 'string' && entry[0] && entry[1])
+                .map(([parentPattern, childrenPatterns]) => [
+                this.getPlatformAwareName(parentPattern.trim()),
+                ( (childrenPatterns.split(',').map(p => this.getPlatformAwareName(p.trim().replace(/\u200b/g, '')))))
+            ])));
+            this.root._fileNester = ( (new ExplorerFileNestingTrie(patterns)));
+        }
+        return this.root._fileNester;
+    }
+    removeChild(child) {
+        this.nestedChildren = undefined;
+        this.children.delete(this.getPlatformAwareName(child.name));
+    }
+    forgetChildren() {
+        this.children.clear();
+        this.nestedChildren = undefined;
+        this._isDirectoryResolved = false;
+        this._fileNester = undefined;
+    }
+    getPlatformAwareName(name) {
+        return this.fileService.hasCapability(this.resource, 1024 ) ? name : name.toLowerCase();
+    }
+    move(newParent) {
+        this.nestedParent?.removeChild(this);
+        this._parent?.removeChild(this);
+        newParent.removeChild(this);
+        newParent.addChild(this);
+        this.updateResource(true);
+    }
+    updateResource(recursive) {
+        if (this._parent) {
+            this.resource = joinPath(this._parent.resource, this.name);
+        }
+        if (recursive) {
+            if (this.isDirectory) {
+                this.children.forEach(child => {
+                    child.updateResource(true);
+                });
             }
-            return `${untitledName}${primaryExtension}`;
         }
-        const filenames = this.languageService.getFilenames(languageId);
-        if (filenames.includes(untitledName)) {
-            return untitledName;
+    }
+    rename(renamedStat) {
+        this.updateName(renamedStat.name);
+        this._mtime = renamedStat.mtime;
+        this.updateResource(true);
+    }
+    find(resource) {
+        const ignoreCase = !this.fileService.hasCapability(resource, 1024 );
+        if (resource && this.resource.scheme === resource.scheme && equalsIgnoreCase(this.resource.authority, resource.authority) &&
+            (ignoreCase ? startsWithIgnoreCase(resource.path, this.resource.path) : resource.path.startsWith(this.resource.path))) {
+            return this.findByPath(rtrim(resource.path, posix.sep), this.resource.path.length, ignoreCase);
         }
-        return firstOrDefault(filenames) ?? untitledName;
+        return null;
     }
-    async revert(resource, options) {
-        if (resource.scheme === Schemas.untitled) {
-            const model = this.untitled.get(resource);
-            if (model) {
-                return model.revert(options);
-            }
+    findByPath(path, index, ignoreCase) {
+        if (isEqual$1(rtrim(this.resource.path, posix.sep), path, ignoreCase)) {
+            return this;
         }
-        else {
-            const model = this.files.get(resource);
-            if (model && (model.isDirty() || options?.force)) {
-                return model.revert(options);
+        if (this.isDirectory) {
+            while (index < path.length && path[index] === posix.sep) {
+                index++;
+            }
+            let indexOfNextSep = path.indexOf(posix.sep, index);
+            if (indexOfNextSep === -1) {
+                indexOfNextSep = path.length;
+            }
+            const name = path.substring(index, indexOfNextSep);
+            const child = this.children.get(this.getPlatformAwareName(name));
+            if (child) {
+                return child.findByPath(path, indexOfNextSep, ignoreCase);
             }
         }
+        return null;
     }
-    isDirty(resource) {
-        const model = resource.scheme === Schemas.untitled ? this.untitled.get(resource) : this.files.get(resource);
-        if (model) {
-            return model.isDirty();
-        }
-        return false;
+}
+ExplorerItem.__decorator = ( (__decorate([
+    memoize
+], ExplorerItem.prototype, "children", null)));
+class NewExplorerItem extends ExplorerItem {
+    constructor(fileService, configService, parent, isDirectory) {
+        super(URI.file(''), fileService, configService, parent, isDirectory);
+        this._isDirectoryResolved = true;
     }
-};
-AbstractTextFileService.TEXTFILE_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource('textFileCreate.source', ( (localize('textFileCreate.source', "File Created"))));
-AbstractTextFileService.TEXTFILE_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource('textFileOverwrite.source', ( (localize('textFileOverwrite.source', "File Replaced"))));
-AbstractTextFileService = ( (__decorate([
-    ( (__param(0, IFileService))),
-    ( (__param(1, IUntitledTextEditorService))),
-    ( (__param(2, ILifecycleService))),
-    ( (__param(3, IInstantiationService))),
-    ( (__param(4, IModelService))),
-    ( (__param(5, IWorkbenchEnvironmentService))),
-    ( (__param(6, IDialogService))),
-    ( (__param(7, IFileDialogService))),
-    ( (__param(8, ITextResourceConfigurationService))),
-    ( (__param(9, IFilesConfigurationService))),
-    ( (__param(10, ICodeEditorService))),
-    ( (__param(11, IPathService))),
-    ( (__param(12, IWorkingCopyFileService))),
-    ( (__param(13, IUriIdentityService))),
-    ( (__param(14, ILanguageService))),
-    ( (__param(15, ILogService))),
-    ( (__param(16, IElevatedFileService))),
-    ( (__param(17, IDecorationsService)))
-], AbstractTextFileService)));
-let EncodingOracle = class EncodingOracle extends Disposable {
-    get encodingOverrides() { return this._encodingOverrides; }
-    set encodingOverrides(value) { this._encodingOverrides = value; }
-    constructor(textResourceConfigurationService, environmentService, contextService, uriIdentityService) {
+}
+const IExplorerService = ( (createDecorator('explorerService')));
+let ResourceGlobMatcher = class ResourceGlobMatcher extends Disposable {
+    constructor(globFn, shouldUpdate, contextService, configurationService) {
         super();
-        this.textResourceConfigurationService = textResourceConfigurationService;
-        this.environmentService = environmentService;
+        this.globFn = globFn;
+        this.shouldUpdate = shouldUpdate;
         this.contextService = contextService;
-        this.uriIdentityService = uriIdentityService;
-        this._encodingOverrides = this.getDefaultEncodingOverrides();
+        this.configurationService = configurationService;
+        this._onExpressionChange = this._register(( (new Emitter())));
+        this.onExpressionChange = this._onExpressionChange.event;
+        this.mapRootToParsedExpression = ( (new Map()));
+        this.mapRootToExpressionConfig = ( (new Map()));
+        this.updateExcludes(false);
         this.registerListeners();
     }
     registerListeners() {
-        this._register(this.contextService.onDidChangeWorkspaceFolders(() => this.encodingOverrides = this.getDefaultEncodingOverrides()));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (this.shouldUpdate(e)) {
+                this.updateExcludes(true);
+            }
+        }));
+        this._register(this.contextService.onDidChangeWorkspaceFolders(() => this.updateExcludes(true)));
     }
-    getDefaultEncodingOverrides() {
-        const defaultEncodingOverrides = [];
-        defaultEncodingOverrides.push({ parent: this.environmentService.userRoamingDataHome, encoding: UTF8 });
-        defaultEncodingOverrides.push({ extension: WORKSPACE_EXTENSION, encoding: UTF8 });
-        defaultEncodingOverrides.push({ parent: this.environmentService.untitledWorkspacesHome, encoding: UTF8 });
+    updateExcludes(fromEvent) {
+        let changed = false;
         this.contextService.getWorkspace().folders.forEach(folder => {
-            defaultEncodingOverrides.push({ parent: joinPath(folder.uri, '.vscode'), encoding: UTF8 });
+            const rootExcludes = this.globFn(folder.uri);
+            if (!this.mapRootToExpressionConfig.has(( (folder.uri.toString()))) || !equals(this.mapRootToExpressionConfig.get(( (folder.uri.toString()))), rootExcludes)) {
+                changed = true;
+                this.mapRootToParsedExpression.set(( (folder.uri.toString())), parse(rootExcludes));
+                this.mapRootToExpressionConfig.set(( (folder.uri.toString())), deepClone(rootExcludes));
+            }
+        });
+        this.mapRootToExpressionConfig.forEach((value, root) => {
+            if (root === ResourceGlobMatcher.NO_ROOT) {
+                return;
+            }
+            if (root && !this.contextService.getWorkspaceFolder(( (URI.parse(root))))) {
+                this.mapRootToParsedExpression.delete(root);
+                this.mapRootToExpressionConfig.delete(root);
+                changed = true;
+            }
         });
-        return defaultEncodingOverrides;
+        const globalExcludes = this.globFn();
+        if (!this.mapRootToExpressionConfig.has(ResourceGlobMatcher.NO_ROOT) || !equals(this.mapRootToExpressionConfig.get(ResourceGlobMatcher.NO_ROOT), globalExcludes)) {
+            changed = true;
+            this.mapRootToParsedExpression.set(ResourceGlobMatcher.NO_ROOT, parse(globalExcludes));
+            this.mapRootToExpressionConfig.set(ResourceGlobMatcher.NO_ROOT, deepClone(globalExcludes));
+        }
+        if (fromEvent && changed) {
+            this._onExpressionChange.fire();
+        }
     }
-    async getWriteEncoding(resource, options) {
-        const { encoding, hasBOM } = await this.getPreferredWriteEncoding(resource, options ? options.encoding : undefined);
-        return { encoding, addBOM: hasBOM };
+    matches(resource, hasSibling) {
+        const folder = this.contextService.getWorkspaceFolder(resource);
+        let expressionForRoot;
+        if (folder && this.mapRootToParsedExpression.has(( (folder.uri.toString())))) {
+            expressionForRoot = this.mapRootToParsedExpression.get(( (folder.uri.toString())));
+        }
+        else {
+            expressionForRoot = this.mapRootToParsedExpression.get(ResourceGlobMatcher.NO_ROOT);
+        }
+        let resourcePathToMatch;
+        if (folder) {
+            resourcePathToMatch = relativePath(folder.uri, resource);
+        }
+        else {
+            resourcePathToMatch = resource.fsPath;
+        }
+        return !!expressionForRoot && typeof resourcePathToMatch === 'string' && !!expressionForRoot(resourcePathToMatch, undefined, hasSibling);
     }
-    async getPreferredWriteEncoding(resource, preferredEncoding) {
-        const resourceEncoding = await this.getEncodingForResource(resource, preferredEncoding);
+};
+ResourceGlobMatcher.NO_ROOT = null;
+ResourceGlobMatcher = ( (__decorate([
+    ( (__param(2, IWorkspaceContextService))),
+    ( (__param(3, IConfigurationService)))
+], ResourceGlobMatcher)));
+const UNDO_REDO_SOURCE = ( (new UndoRedoSource()));
+let ExplorerService = class ExplorerService {
+    constructor(fileService, configurationService, contextService, clipboardService, editorService, uriIdentityService, bulkEditService, progressService, hostService) {
+        this.fileService = fileService;
+        this.configurationService = configurationService;
+        this.contextService = contextService;
+        this.clipboardService = clipboardService;
+        this.editorService = editorService;
+        this.uriIdentityService = uriIdentityService;
+        this.bulkEditService = bulkEditService;
+        this.progressService = progressService;
+        this.disposables = ( (new DisposableStore()));
+        this.fileChangeEvents = [];
+        this.config = this.configurationService.getValue('explorer');
+        this.model = ( (new ExplorerModel(
+            this.contextService,
+            this.uriIdentityService,
+            this.fileService,
+            this.configurationService
+        )));
+        this.disposables.add(this.model);
+        this.disposables.add(this.fileService.onDidRunOperation(e => this.onDidRunOperation(e)));
+        this.onFileChangesScheduler = ( (new RunOnceScheduler(async () => {
+            const events = this.fileChangeEvents;
+            this.fileChangeEvents = [];
+            const types = [2 ];
+            if (this.config.sortOrder === "modified" ) {
+                types.push(0 );
+            }
+            let shouldRefresh = false;
+            this.roots.forEach(r => {
+                if (this.view && !shouldRefresh) {
+                    shouldRefresh = doesFileEventAffect(r, this.view, events, types);
+                }
+            });
+            events.forEach(e => {
+                if (!shouldRefresh) {
+                    for (const resource of e.rawAdded) {
+                        const parent = this.model.findClosest(dirname(resource));
+                        if (parent && !parent.getChild(basename(resource))) {
+                            shouldRefresh = true;
+                            break;
+                        }
+                    }
+                }
+            });
+            if (shouldRefresh) {
+                await this.refresh(false);
+            }
+        }, ExplorerService.EXPLORER_FILE_CHANGES_REACT_DELAY)));
+        this.disposables.add(this.fileService.onDidFilesChange(e => {
+            this.fileChangeEvents.push(e);
+            if (this.editable) {
+                return;
+            }
+            if (!this.onFileChangesScheduler.isScheduled()) {
+                this.onFileChangesScheduler.schedule();
+            }
+        }));
+        this.disposables.add(this.configurationService.onDidChangeConfiguration(e => this.onConfigurationUpdated(e)));
+        this.disposables.add(Event.any(this.fileService.onDidChangeFileSystemProviderRegistrations, this.fileService.onDidChangeFileSystemProviderCapabilities)(async (e) => {
+            let affected = false;
+            this.model.roots.forEach(r => {
+                if (r.resource.scheme === e.scheme) {
+                    affected = true;
+                    r.forgetChildren();
+                }
+            });
+            if (affected) {
+                if (this.view) {
+                    await this.view.setTreeInput();
+                }
+            }
+        }));
+        this.disposables.add(this.model.onDidChangeRoots(() => {
+            this.view?.setTreeInput();
+        }));
+        this.disposables.add(hostService.onDidChangeFocus(hasFocus => {
+            if (hasFocus) {
+                this.refresh(false);
+            }
+        }));
+        this.revealExcludeMatcher = ( (new ResourceGlobMatcher(
+            (uri) => getRevealExcludes(configurationService.getValue({ resource: uri })),
+            (event) => event.affectsConfiguration('explorer.autoRevealExclude'),
+            contextService,
+            configurationService
+        )));
+        this.disposables.add(this.revealExcludeMatcher);
+    }
+    get roots() {
+        return this.model.roots;
+    }
+    get sortOrderConfiguration() {
         return {
-            encoding: resourceEncoding,
-            hasBOM: resourceEncoding === UTF16be || resourceEncoding === UTF16le || resourceEncoding === UTF8_with_bom
+            sortOrder: this.config.sortOrder,
+            lexicographicOptions: this.config.sortOrderLexicographicOptions,
         };
     }
-    async getPreferredReadEncoding(resource, options, detectedEncoding) {
-        let preferredEncoding;
-        if (options?.encoding) {
-            if (detectedEncoding === UTF8_with_bom && options.encoding === UTF8) {
-                preferredEncoding = UTF8_with_bom;
+    registerView(contextProvider) {
+        this.view = contextProvider;
+    }
+    getContext(respectMultiSelection, ignoreNestedChildren = false) {
+        if (!this.view) {
+            return [];
+        }
+        const items = ( (new Set(this.view.getContext(respectMultiSelection))));
+        items.forEach(item => {
+            try {
+                if (respectMultiSelection && !ignoreNestedChildren && this.view?.isItemCollapsed(item) && item.nestedChildren) {
+                    for (const child of item.nestedChildren) {
+                        items.add(child);
+                    }
+                }
             }
-            else {
-                preferredEncoding = options.encoding;
+            catch {
+                return;
             }
+        });
+        return [...items];
+    }
+    async applyBulkEdit(edit, options) {
+        const cancellationTokenSource = ( (new CancellationTokenSource()));
+        const promise = this.progressService.withProgress({
+            location: options.progressLocation || 10 ,
+            title: options.progressLabel,
+            cancellable: edit.length > 1,
+            delay: 500,
+        }, async (progress) => {
+            await this.bulkEditService.apply(edit, {
+                undoRedoSource: UNDO_REDO_SOURCE,
+                label: options.undoLabel,
+                code: 'undoredo.explorerOperation',
+                progress,
+                token: cancellationTokenSource.token,
+                confirmBeforeUndo: options.confirmBeforeUndo
+            });
+        }, () => cancellationTokenSource.cancel());
+        await this.progressService.withProgress({ location: 1 , delay: 500 }, () => promise);
+        cancellationTokenSource.dispose();
+    }
+    hasViewFocus() {
+        return !!this.view && this.view.hasFocus();
+    }
+    findClosest(resource) {
+        return this.model.findClosest(resource);
+    }
+    findClosestRoot(resource) {
+        const parentRoots = this.model.roots.filter(r => this.uriIdentityService.extUri.isEqualOrParent(resource, r.resource))
+            .sort((first, second) => second.resource.path.length - first.resource.path.length);
+        return parentRoots.length ? parentRoots[0] : null;
+    }
+    async setEditable(stat, data) {
+        if (!this.view) {
+            return;
         }
-        else if (typeof detectedEncoding === 'string') {
-            preferredEncoding = detectedEncoding;
+        if (!data) {
+            this.editable = undefined;
         }
-        else if (this.textResourceConfigurationService.getValue(resource, 'files.encoding') === UTF8_with_bom) {
-            preferredEncoding = UTF8;
+        else {
+            this.editable = { stat, data };
         }
-        const encoding = await this.getEncodingForResource(resource, preferredEncoding);
-        return {
-            encoding,
-            hasBOM: encoding === UTF16be || encoding === UTF16le || encoding === UTF8_with_bom
-        };
+        const isEditing = this.isEditable(stat);
+        await this.view.setEditable(stat, isEditing);
+        if (!this.editable && this.fileChangeEvents.length && !this.onFileChangesScheduler.isScheduled()) {
+            this.onFileChangesScheduler.schedule();
+        }
+    }
+    async setToCopy(items, cut) {
+        const previouslyCutItems = this.cutItems;
+        this.cutItems = cut ? items : undefined;
+        await this.clipboardService.writeResources(( (items.map(s => s.resource))));
+        this.view?.itemsCopied(items, cut, previouslyCutItems);
+    }
+    isCut(item) {
+        return !!this.cutItems && this.cutItems.some(i => this.uriIdentityService.extUri.isEqual(i.resource, item.resource));
+    }
+    getEditable() {
+        return this.editable;
     }
-    async getEncodingForResource(resource, preferredEncoding) {
-        let fileEncoding;
-        const override = this.getEncodingOverride(resource);
-        if (override) {
-            fileEncoding = override;
+    getEditableData(stat) {
+        return this.editable && this.editable.stat === stat ? this.editable.data : undefined;
+    }
+    isEditable(stat) {
+        return !!this.editable && (this.editable.stat === stat || !stat);
+    }
+    async select(resource, reveal) {
+        if (!this.view) {
+            return;
         }
-        else if (preferredEncoding) {
-            fileEncoding = preferredEncoding;
+        const ignoreRevealExcludes = reveal === 'force';
+        const fileStat = this.findClosest(resource);
+        if (fileStat) {
+            if (!this.shouldAutoRevealItem(fileStat, ignoreRevealExcludes)) {
+                return;
+            }
+            await this.view.selectResource(fileStat.resource, reveal);
+            return Promise.resolve(undefined);
         }
-        else {
-            fileEncoding = this.textResourceConfigurationService.getValue(resource, 'files.encoding');
+        const options = { resolveTo: [resource], resolveMetadata: this.config.sortOrder === "modified"  };
+        const root = this.findClosestRoot(resource);
+        if (!root) {
+            return undefined;
+        }
+        try {
+            const stat = await this.fileService.resolve(root.resource, options);
+            const modelStat = ExplorerItem.create(this.fileService, this.configurationService, stat, undefined, options.resolveTo);
+            ExplorerItem.mergeLocalWithDisk(modelStat, root);
+            const item = root.find(resource);
+            await this.view.refresh(true, root);
+            if (item && !this.shouldAutoRevealItem(item, ignoreRevealExcludes)) {
+                return;
+            }
+            await this.view.selectResource(item ? item.resource : undefined, reveal);
         }
-        if (fileEncoding !== UTF8) {
-            if (!fileEncoding || !(await encodingExists(fileEncoding))) {
-                fileEncoding = UTF8;
+        catch (error) {
+            root.error = error;
+            await this.view.refresh(false, root);
+        }
+    }
+    async refresh(reveal = true) {
+        this.model.roots.forEach(r => r.forgetChildren());
+        if (this.view) {
+            await this.view.refresh(true);
+            const resource = this.editorService.activeEditor?.resource;
+            const autoReveal = this.configurationService.getValue().explorer.autoReveal;
+            if (reveal && resource && autoReveal) {
+                this.select(resource, autoReveal);
+            }
+        }
+    }
+    async onDidRunOperation(e) {
+        const shouldDeepRefresh = this.config.fileNesting.enabled;
+        if (e.isOperation(0 ) || e.isOperation(3 )) {
+            const addedElement = e.target;
+            const parentResource = dirname(addedElement.resource);
+            const parents = this.model.findAll(parentResource);
+            if (parents.length) {
+                await Promise.all(( (parents.map(async (p) => {
+                    const resolveMetadata = this.config.sortOrder === `modified`;
+                    if (!p.isDirectoryResolved) {
+                        const stat = await this.fileService.resolve(p.resource, { resolveMetadata });
+                        if (stat) {
+                            const modelStat = ExplorerItem.create(this.fileService, this.configurationService, stat, p.parent);
+                            ExplorerItem.mergeLocalWithDisk(modelStat, p);
+                        }
+                    }
+                    const childElement = ExplorerItem.create(this.fileService, this.configurationService, addedElement, p.parent);
+                    p.removeChild(childElement);
+                    p.addChild(childElement);
+                    await this.view?.refresh(shouldDeepRefresh, p);
+                }))));
             }
         }
-        return fileEncoding;
-    }
-    getEncodingOverride(resource) {
-        if (this.encodingOverrides?.length) {
-            for (const override of this.encodingOverrides) {
-                if (override.parent && this.uriIdentityService.extUri.isEqualOrParent(resource, override.parent)) {
-                    return override.encoding;
+        else if (e.isOperation(2 )) {
+            const oldResource = e.resource;
+            const newElement = e.target;
+            const oldParentResource = dirname(oldResource);
+            const newParentResource = dirname(newElement.resource);
+            const modelElements = this.model.findAll(oldResource);
+            const sameParentMove = modelElements.every(e => !e.nestedParent) && this.uriIdentityService.extUri.isEqual(oldParentResource, newParentResource);
+            if (sameParentMove) {
+                await Promise.all(( (modelElements.map(async (modelElement) => {
+                    modelElement.rename(newElement);
+                    await this.view?.refresh(shouldDeepRefresh, modelElement.parent);
+                }))));
+            }
+            else {
+                const newParents = this.model.findAll(newParentResource);
+                if (newParents.length && modelElements.length) {
+                    await Promise.all(( (modelElements.map(async (modelElement, index) => {
+                        const oldParent = modelElement.parent;
+                        const oldNestedParent = modelElement.nestedParent;
+                        modelElement.move(newParents[index]);
+                        if (oldNestedParent) {
+                            await this.view?.refresh(false, oldNestedParent);
+                        }
+                        await this.view?.refresh(false, oldParent);
+                        await this.view?.refresh(shouldDeepRefresh, newParents[index]);
+                    }))));
                 }
-                if (override.extension && extname$1(resource) === `.${override.extension}`) {
-                    return override.encoding;
+            }
+        }
+        else if (e.isOperation(1 )) {
+            const modelElements = this.model.findAll(e.resource);
+            await Promise.all(( (modelElements.map(async (modelElement) => {
+                if (modelElement.parent) {
+                    const parent = modelElement.parent;
+                    parent.removeChild(modelElement);
+                    const oldNestedParent = modelElement.nestedParent;
+                    if (oldNestedParent) {
+                        oldNestedParent.removeChild(modelElement);
+                        await this.view?.refresh(false, oldNestedParent);
+                    }
+                    await this.view?.refresh(shouldDeepRefresh, parent);
                 }
+            }))));
+        }
+    }
+    shouldAutoRevealItem(item, ignore) {
+        if (item === undefined || ignore) {
+            return true;
+        }
+        if (this.revealExcludeMatcher.matches(item.resource, name => !!(item.parent && item.parent.getChild(name)))) {
+            return false;
+        }
+        const root = item.root;
+        let currentItem = item.parent;
+        while (currentItem !== root) {
+            if (currentItem === undefined) {
+                return true;
+            }
+            if (this.revealExcludeMatcher.matches(currentItem.resource)) {
+                return false;
             }
+            currentItem = currentItem.parent;
+        }
+        return true;
+    }
+    async onConfigurationUpdated(event) {
+        if (!event.affectsConfiguration('explorer')) {
+            return;
+        }
+        let shouldRefresh = false;
+        if (event.affectsConfiguration('explorer.fileNesting')) {
+            shouldRefresh = true;
+        }
+        const configuration = this.configurationService.getValue();
+        const configSortOrder = configuration?.explorer?.sortOrder || "default" ;
+        if (this.config.sortOrder !== configSortOrder) {
+            shouldRefresh = this.config.sortOrder !== undefined;
+        }
+        const configLexicographicOptions = configuration?.explorer?.sortOrderLexicographicOptions || "default" ;
+        if (this.config.sortOrderLexicographicOptions !== configLexicographicOptions) {
+            shouldRefresh = shouldRefresh || this.config.sortOrderLexicographicOptions !== undefined;
         }
-        return undefined;
+        this.config = configuration.explorer;
+        if (shouldRefresh) {
+            await this.refresh();
+        }
+    }
+    dispose() {
+        this.disposables.dispose();
     }
 };
-EncodingOracle = ( (__decorate([
-    ( (__param(0, ITextResourceConfigurationService))),
-    ( (__param(1, IWorkbenchEnvironmentService))),
+ExplorerService.EXPLORER_FILE_CHANGES_REACT_DELAY = 500;
+ExplorerService = ( (__decorate([
+    ( (__param(0, IFileService))),
+    ( (__param(1, IConfigurationService))),
     ( (__param(2, IWorkspaceContextService))),
-    ( (__param(3, IUriIdentityService)))
-], EncodingOracle)));
-let BrowserTextFileService = class BrowserTextFileService extends AbstractTextFileService {
-    constructor(fileService, untitledTextEditorService, lifecycleService, instantiationService, modelService, environmentService, dialogService, fileDialogService, textResourceConfigurationService, filesConfigurationService, codeEditorService, pathService, workingCopyFileService, uriIdentityService, languageService, elevatedFileService, logService, decorationsService) {
-        super(fileService, untitledTextEditorService, lifecycleService, instantiationService, modelService, environmentService, dialogService, fileDialogService, textResourceConfigurationService, filesConfigurationService, codeEditorService, pathService, workingCopyFileService, uriIdentityService, languageService, logService, elevatedFileService, decorationsService);
-        this.registerListeners();
+    ( (__param(3, IClipboardService))),
+    ( (__param(4, IEditorService))),
+    ( (__param(5, IUriIdentityService))),
+    ( (__param(6, IBulkEditService))),
+    ( (__param(7, IProgressService))),
+    ( (__param(8, IHostService)))
+], ExplorerService)));
+function doesFileEventAffect(item, view, events, types) {
+    for (const [_name, child] of item.children) {
+        if (view.isItemVisible(child)) {
+            if (events.some(e => e.contains(child.resource, ...types))) {
+                return true;
+            }
+            if (child.isDirectory && child.isDirectoryResolved) {
+                if (doesFileEventAffect(child, view, events, types)) {
+                    return true;
+                }
+            }
+        }
     }
-    registerListeners() {
-        this.lifecycleService.onBeforeShutdown(event => event.veto(this.onBeforeShutdown(), 'veto.textFiles'));
+    return false;
+}
+function getRevealExcludes(configuration) {
+    const revealExcludes = configuration && configuration.explorer && configuration.explorer.autoRevealExclude;
+    if (!revealExcludes) {
+        return {};
     }
-    onBeforeShutdown() {
-        if (this.files.models.some(model => model.hasState(2 ))) {
-            return true;
+    return revealExcludes;
+}
+( (Registry.as(EditorExtensions.EditorFactory))).registerFileEditorFactory({
+    typeId: FILE_EDITOR_INPUT_ID,
+    createFileEditor: (resource, preferredResource, preferredName, preferredDescription, preferredEncoding, preferredLanguageId, preferredContents, instantiationService) => {
+        return instantiationService.createInstance(FileEditorInput, resource, preferredResource, preferredName, preferredDescription, preferredEncoding, preferredLanguageId, preferredContents);
+    },
+    isFileEditor: (obj) => {
+        return obj instanceof FileEditorInput;
+    }
+});
+const configurationRegistry = ( (Registry.as(Extensions.Configuration)));
+const hotExitConfiguration = isNative ?
+    {
+        'type': 'string',
+        'scope': 1 ,
+        'enum': [HotExitConfiguration.OFF, HotExitConfiguration.ON_EXIT, HotExitConfiguration.ON_EXIT_AND_WINDOW_CLOSE],
+        'default': HotExitConfiguration.ON_EXIT,
+        'markdownEnumDescriptions': [
+            ( (localize(
+            'hotExit.off',
+            'Disable hot exit. A prompt will show when attempting to close a window with editors that have unsaved changes.'
+        ))),
+            ( (localize(
+            'hotExit.onExit',
+            'Hot exit will be triggered when the last window is closed on Windows/Linux or when the `workbench.action.quit` command is triggered (command palette, keybinding, menu). All windows without folders opened will be restored upon next launch. A list of previously opened windows with unsaved files can be accessed via `File > Open Recent > More...`'
+        ))),
+            ( (localize(
+            'hotExit.onExitAndWindowClose',
+            'Hot exit will be triggered when the last window is closed on Windows/Linux or when the `workbench.action.quit` command is triggered (command palette, keybinding, menu), and also for any window with a folder opened regardless of whether it\'s the last window. All windows without folders opened will be restored upon next launch. A list of previously opened windows with unsaved files can be accessed via `File > Open Recent > More...`'
+        )))
+        ],
+        'description': ( (localize(
+            'hotExit',
+            "Controls whether unsaved files are remembered between sessions, allowing the save prompt when exiting the editor to be skipped.",
+            HotExitConfiguration.ON_EXIT,
+            HotExitConfiguration.ON_EXIT_AND_WINDOW_CLOSE
+        )))
+    } : {
+    'type': 'string',
+    'scope': 1 ,
+    'enum': [HotExitConfiguration.OFF, HotExitConfiguration.ON_EXIT_AND_WINDOW_CLOSE],
+    'default': HotExitConfiguration.ON_EXIT_AND_WINDOW_CLOSE,
+    'markdownEnumDescriptions': [
+        ( (localize(
+        'hotExit.off',
+        'Disable hot exit. A prompt will show when attempting to close a window with editors that have unsaved changes.'
+    ))),
+        ( (localize(
+        'hotExit.onExitAndWindowCloseBrowser',
+        'Hot exit will be triggered when the browser quits or the window or tab is closed.'
+    )))
+    ],
+    'description': ( (localize(
+        'hotExit',
+        "Controls whether unsaved files are remembered between sessions, allowing the save prompt when exiting the editor to be skipped.",
+        HotExitConfiguration.ON_EXIT,
+        HotExitConfiguration.ON_EXIT_AND_WINDOW_CLOSE
+    )))
+};
+configurationRegistry.registerConfiguration({
+    'id': 'files',
+    'order': 9,
+    'title': ( (localize('filesConfigurationTitle', "Files"))),
+    'type': 'object',
+    'properties': {
+        [FILES_EXCLUDE_CONFIG]: {
+            'type': 'object',
+            'markdownDescription': ( (localize(
+                'exclude',
+                "Configure [glob patterns](https://code.visualstudio.com/docs/editor/codebasics#_advanced-search-options) for excluding files and folders. For example, the File Explorer decides which files and folders to show or hide based on this setting. Refer to the `#search.exclude#` setting to define search-specific excludes. Refer to the `#explorer.excludeGitIgnore#` setting for ignoring files based on your `.gitignore`."
+            ))),
+            'default': {
+                ...{ '**/.git': true, '**/.svn': true, '**/.hg': true, '**/CVS': true, '**/.DS_Store': true, '**/Thumbs.db': true },
+                ...(isWeb ? { '**/*.crswap': true  } : undefined)
+            },
+            'scope': 4 ,
+            'additionalProperties': {
+                'anyOf': [
+                    {
+                        'type': 'boolean',
+                        'enum': [true, false],
+                        'enumDescriptions': [( (localize('trueDescription', "Enable the pattern."))), ( (localize('falseDescription', "Disable the pattern.")))],
+                        'description': ( (localize(
+                            'files.exclude.boolean',
+                            "The glob pattern to match file paths against. Set to true or false to enable or disable the pattern."
+                        ))),
+                    },
+                    {
+                        'type': 'object',
+                        'properties': {
+                            'when': {
+                                'type': 'string',
+                                'pattern': '\\w*\\$\\(basename\\)\\w*',
+                                'default': '$(basename).ext',
+                                'markdownDescription': ( (localize(
+                                    { key: 'files.exclude.when', comment: ['\\$(basename) should not be translated'] },
+                                    "Additional check on the siblings of a matching file. Use \\$(basename) as variable for the matching file name."
+                                )))
+                            }
+                        }
+                    }
+                ]
+            }
+        },
+        [FILES_ASSOCIATIONS_CONFIG]: {
+            'type': 'object',
+            'markdownDescription': ( (localize(
+                'associations',
+                "Configure file associations to languages (for example `\"*.extension\": \"html\"`). These have precedence over the default associations of the languages installed."
+            ))),
+            'additionalProperties': {
+                'type': 'string'
+            }
+        },
+        'files.encoding': {
+            'type': 'string',
+            'enum': ( (Object.keys(SUPPORTED_ENCODINGS))),
+            'default': 'utf8',
+            'description': ( (localize(
+                'encoding',
+                "The default character set encoding to use when reading and writing files. This setting can also be configured per language."
+            ))),
+            'scope': 5 ,
+            'enumDescriptions': ( (( (Object.keys(SUPPORTED_ENCODINGS))).map(key => SUPPORTED_ENCODINGS[key].labelLong))),
+            'enumItemLabels': ( (( (Object.keys(SUPPORTED_ENCODINGS))).map(key => SUPPORTED_ENCODINGS[key].labelLong)))
+        },
+        'files.autoGuessEncoding': {
+            'type': 'boolean',
+            'default': false,
+            'markdownDescription': ( (localize(
+                'autoGuessEncoding',
+                "When enabled, the editor will attempt to guess the character set encoding when opening files. This setting can also be configured per language. Note, this setting is not respected by text search. Only {0} is respected.",
+                '`#files.encoding#`'
+            ))),
+            'scope': 5
+        },
+        'files.eol': {
+            'type': 'string',
+            'enum': [
+                '\n',
+                '\r\n',
+                'auto'
+            ],
+            'enumDescriptions': [
+                ( (localize('eol.LF', "LF"))),
+                ( (localize('eol.CRLF', "CRLF"))),
+                ( (localize('eol.auto', "Uses operating system specific end of line character.")))
+            ],
+            'default': 'auto',
+            'description': ( (localize('eol', "The default end of line character."))),
+            'scope': 5
+        },
+        'files.enableTrash': {
+            'type': 'boolean',
+            'default': true,
+            'description': ( (localize(
+                'useTrash',
+                "Moves files/folders to the OS trash (recycle bin on Windows) when deleting. Disabling this will delete files/folders permanently."
+            )))
+        },
+        'files.trimTrailingWhitespace': {
+            'type': 'boolean',
+            'default': false,
+            'description': ( (localize(
+                'trimTrailingWhitespace',
+                "When enabled, will trim trailing whitespace when saving a file."
+            ))),
+            'scope': 5
+        },
+        'files.insertFinalNewline': {
+            'type': 'boolean',
+            'default': false,
+            'description': ( (localize(
+                'insertFinalNewline',
+                "When enabled, insert a final new line at the end of the file when saving it."
+            ))),
+            'scope': 5
+        },
+        'files.trimFinalNewlines': {
+            'type': 'boolean',
+            'default': false,
+            'description': ( (localize(
+                'trimFinalNewlines',
+                "When enabled, will trim all new lines after the final new line at the end of the file when saving it."
+            ))),
+            scope: 5 ,
+        },
+        'files.autoSave': {
+            'type': 'string',
+            'enum': [AutoSaveConfiguration.OFF, AutoSaveConfiguration.AFTER_DELAY, AutoSaveConfiguration.ON_FOCUS_CHANGE, AutoSaveConfiguration.ON_WINDOW_CHANGE],
+            'markdownEnumDescriptions': [
+                ( (localize(
+                { comment: ['This is the description for a setting. Values surrounded by single quotes are not to be translated.'], key: 'files.autoSave.off' },
+                "An editor with changes is never automatically saved."
+            ))),
+                ( (localize(
+                { comment: ['This is the description for a setting. Values surrounded by single quotes are not to be translated.'], key: 'files.autoSave.afterDelay' },
+                "An editor with changes is automatically saved after the configured `#files.autoSaveDelay#`."
+            ))),
+                ( (localize(
+                { comment: ['This is the description for a setting. Values surrounded by single quotes are not to be translated.'], key: 'files.autoSave.onFocusChange' },
+                "An editor with changes is automatically saved when the editor loses focus."
+            ))),
+                ( (localize(
+                { comment: ['This is the description for a setting. Values surrounded by single quotes are not to be translated.'], key: 'files.autoSave.onWindowChange' },
+                "An editor with changes is automatically saved when the window loses focus."
+            )))
+            ],
+            'default': isWeb ? AutoSaveConfiguration.AFTER_DELAY : AutoSaveConfiguration.OFF,
+            'markdownDescription': ( (localize(
+                { comment: ['This is the description for a setting. Values surrounded by single quotes are not to be translated.'], key: 'autoSave' },
+                "Controls [auto save](https://code.visualstudio.com/docs/editor/codebasics#_save-auto-save) of editors that have unsaved changes.",
+                AutoSaveConfiguration.OFF,
+                AutoSaveConfiguration.AFTER_DELAY,
+                AutoSaveConfiguration.ON_FOCUS_CHANGE,
+                AutoSaveConfiguration.ON_WINDOW_CHANGE,
+                AutoSaveConfiguration.AFTER_DELAY
+            )))
+        },
+        'files.autoSaveDelay': {
+            'type': 'number',
+            'default': 1000,
+            'minimum': 0,
+            'markdownDescription': ( (localize(
+                { comment: ['This is the description for a setting. Values surrounded by single quotes are not to be translated.'], key: 'autoSaveDelay' },
+                "Controls the delay in milliseconds after which an editor with unsaved changes is saved automatically. Only applies when `#files.autoSave#` is set to `{0}`.",
+                AutoSaveConfiguration.AFTER_DELAY
+            )))
+        },
+        'files.watcherExclude': {
+            'type': 'object',
+            'default': { '**/.git/objects/**': true, '**/.git/subtree-cache/**': true, '**/node_modules/*/**': true, '**/.hg/store/**': true },
+            'markdownDescription': ( (localize(
+                'watcherExclude',
+                "Configure paths or glob patterns to exclude from file watching. Paths can either be relative to the watched folder or absolute. Glob patterns are matched relative from the watched folder. When you experience the file watcher process consuming a lot of CPU, make sure to exclude large folders that are of less interest (such as build output folders)."
+            ))),
+            'scope': 4
+        },
+        'files.watcherInclude': {
+            'type': 'array',
+            'items': {
+                'type': 'string'
+            },
+            'default': [],
+            'description': ( (localize(
+                'watcherInclude',
+                "Configure extra paths to watch for changes inside the workspace. By default, all workspace folders will be watched recursively, except for folders that are symbolic links. You can explicitly add absolute or relative paths to support watching folders that are symbolic links. Relative paths will be resolved to an absolute path using the currently opened workspace."
+            ))),
+            'scope': 4
+        },
+        'files.hotExit': hotExitConfiguration,
+        'files.defaultLanguage': {
+            'type': 'string',
+            'markdownDescription': ( (localize(
+                'defaultLanguage',
+                "The default language identifier that is assigned to new files. If configured to `${activeEditorLanguage}`, will use the language identifier of the currently active text editor if any."
+            )))
+        },
+        'files.maxMemoryForLargeFilesMB': {
+            'type': 'number',
+            'default': 4096,
+            'minimum': 0,
+            'markdownDescription': ( (localize(
+                'maxMemoryForLargeFilesMB',
+                "Controls the memory available to VS Code after restart when trying to open large files. Same effect as specifying `--max-memory=NEWSIZE` on the command line."
+            ))),
+            included: isNative
+        },
+        'files.restoreUndoStack': {
+            'type': 'boolean',
+            'description': ( (localize(
+                'files.restoreUndoStack',
+                "Restore the undo stack when a file is reopened."
+            ))),
+            'default': true
+        },
+        'files.saveConflictResolution': {
+            'type': 'string',
+            'enum': [
+                'askUser',
+                'overwriteFileOnDisk'
+            ],
+            'enumDescriptions': [
+                ( (localize(
+                'askUser',
+                "Will refuse to save and ask for resolving the save conflict manually."
+            ))),
+                ( (localize(
+                'overwriteFileOnDisk',
+                "Will resolve the save conflict by overwriting the file on disk with the changes in the editor."
+            )))
+            ],
+            'description': ( (localize(
+                'files.saveConflictResolution',
+                "A save conflict can occur when a file is saved to disk that was changed by another program in the meantime. To prevent data loss, the user is asked to compare the changes in the editor with the version on disk. This setting should only be changed if you frequently encounter save conflict errors and may result in data loss if used without caution."
+            ))),
+            'default': 'askUser',
+            'scope': 5
+        },
+        'files.simpleDialog.enable': {
+            'type': 'boolean',
+            'description': ( (localize(
+                'files.simpleDialog.enable',
+                "Enables the simple file dialog. The simple file dialog replaces the system file dialog when enabled."
+            ))),
+            'default': false
+        },
+        'files.participants.timeout': {
+            type: 'number',
+            default: 60000,
+            markdownDescription: ( (localize(
+                'files.participants.timeout',
+                "Timeout in milliseconds after which file participants for create, rename, and delete are cancelled. Use `0` to disable participants."
+            ))),
         }
-        return false;
     }
-};
-BrowserTextFileService = ( (__decorate([
-    ( (__param(0, IFileService))),
-    ( (__param(1, IUntitledTextEditorService))),
-    ( (__param(2, ILifecycleService))),
-    ( (__param(3, IInstantiationService))),
-    ( (__param(4, IModelService))),
-    ( (__param(5, IWorkbenchEnvironmentService))),
-    ( (__param(6, IDialogService))),
-    ( (__param(7, IFileDialogService))),
-    ( (__param(8, ITextResourceConfigurationService))),
-    ( (__param(9, IFilesConfigurationService))),
-    ( (__param(10, ICodeEditorService))),
-    ( (__param(11, IPathService))),
-    ( (__param(12, IWorkingCopyFileService))),
-    ( (__param(13, IUriIdentityService))),
-    ( (__param(14, ILanguageService))),
-    ( (__param(15, IElevatedFileService))),
-    ( (__param(16, ILogService))),
-    ( (__param(17, IDecorationsService)))
-], BrowserTextFileService)));
-let SimpleExtensionResourceLoaderService = class SimpleExtensionResourceLoaderService extends AbstractExtensionResourceLoaderService {
-    constructor(fileService, storageService, productService, environmentService, configurationService) {
-        super(fileService, storageService, productService, environmentService, configurationService);
-    }
-    async readExtensionResource(uri) {
-        const result = await this._fileService.readFile(uri);
-        return ( result.value.toString());
+});
+configurationRegistry.registerConfiguration({
+    ...editorConfigurationBaseNode,
+    properties: {
+        'editor.formatOnSave': {
+            'type': 'boolean',
+            'description': ( (localize(
+                'formatOnSave',
+                "Format a file on save. A formatter must be available, the file must not be saved after delay, and the editor must not be shutting down."
+            ))),
+            'scope': 5 ,
+        },
+        'editor.formatOnSaveMode': {
+            'type': 'string',
+            'default': 'file',
+            'enum': [
+                'file',
+                'modifications',
+                'modificationsIfAvailable'
+            ],
+            'enumDescriptions': [
+                ( (localize(
+                { key: 'everything', comment: ['This is the description of an option'] },
+                "Format the whole file."
+            ))),
+                ( (localize(
+                { key: 'modification', comment: ['This is the description of an option'] },
+                "Format modifications (requires source control)."
+            ))),
+                ( (localize(
+                { key: 'modificationIfAvailable', comment: ['This is the description of an option'] },
+                "Will attempt to format modifications only (requires source control). If source control can't be used, then the whole file will be formatted."
+            ))),
+            ],
+            'markdownDescription': ( (localize(
+                'formatOnSaveMode',
+                "Controls if format on save formats the whole file or only modifications. Only applies when `#editor.formatOnSave#` is enabled."
+            ))),
+            'scope': 5 ,
+        },
+    }
+});
+RedoCommand.addImplementation(110, 'explorer', (accessor) => {
+    const undoRedoService = accessor.get(IUndoRedoService);
+    const explorerService = accessor.get(IExplorerService);
+    const configurationService = accessor.get(IConfigurationService);
+    const explorerCanUndo = configurationService.getValue().explorer.enableUndo;
+    if (explorerService.hasViewFocus() && undoRedoService.canRedo(UNDO_REDO_SOURCE) && explorerCanUndo) {
+        undoRedoService.redo(UNDO_REDO_SOURCE);
+        return true;
     }
-};
-SimpleExtensionResourceLoaderService = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, IStorageService)),
-    ( __param(2, IProductService)),
-    ( __param(3, IEnvironmentService)),
-    ( __param(4, IConfigurationService))
-], SimpleExtensionResourceLoaderService));
-registerSingleton(IExtensionResourceLoaderService, SimpleExtensionResourceLoaderService, 0 );
+    return false;
+});
+ModesRegistry.registerLanguage({
+    id: BINARY_TEXT_FILE_MODE,
+    aliases: ['Binary'],
+    mimetypes: ['text/x-code-binary']
+});
 class File {
     constructor(getContent) {
         this.getContent = getContent;
@@ -2448,17 +2945,71 @@ class File {
     }
 }
 const encoder = new TextEncoder();
-class ExtensionFileSystemProviderWithFileReadWriteCapability {
+const decoder = new TextDecoder();
+class SimpleTextFileSystemProvider {
     constructor() {
+        this.onDidChangeCapabilities = Event.None;
         this.capabilities = 2  | 1024 ;
         this.onDidChangeFile = Event.None;
-        this.onDidChangeCapabilities = Event.None;
         this.onDidWatchError = Event.None;
-        this.writeFile = unsupported;
-        this.mkdir = unsupported;
-        this.readdir = unsupported;
-        this.delete = unsupported;
-        this.rename = unsupported;
+    }
+    async readFile(resource) {
+        try {
+            const content = await this.getFileContent(resource);
+            if (content != null) {
+                return encoder.encode(content);
+            }
+        }
+        catch (err) {
+            throw createFileSystemProviderError(err, FileSystemProviderErrorCode.Unknown);
+        }
+        throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
+    }
+    async writeFile(resource, content, opts) {
+        try {
+            await this.setFileContent(resource, decoder.decode(content), opts);
+        }
+        catch (err) {
+            throw createFileSystemProviderError(err, FileSystemProviderErrorCode.Unknown);
+        }
+    }
+    watch() {
+        return Disposable.None;
+    }
+    async stat(resource) {
+        try {
+            const content = await this.getFileContent(resource);
+            if (content != null) {
+                return {
+                    type: FileType.File,
+                    size: encoder.encode(content).length,
+                    ctime: Date.now(),
+                    mtime: Date.now()
+                };
+            }
+        }
+        catch (err) {
+            throw createFileSystemProviderError(err, FileSystemProviderErrorCode.Unknown);
+        }
+        throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
+    }
+    async mkdir() {
+    }
+    readdir() {
+        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
+    }
+    delete() {
+        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
+    }
+    rename() {
+        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
+    }
+}
+class ExtensionFileSystemProviderWithFileReadWriteCapability {
+    constructor() {
+        this.capabilities = 2  | 1024  | 2048 ;
+        this.onDidChangeFile = Event.None;
+        this.onDidChangeCapabilities = Event.None;
         this.files = new Map();
     }
     async stat(resource) {
@@ -2476,36 +3027,139 @@ class ExtensionFileSystemProviderWithFileReadWriteCapability {
         throw FileSystemProviderError.create('file not found', FileSystemProviderErrorCode.FileNotFound);
     }
     watch() {
-        return {
-            dispose() { }
-        };
+        return Disposable.None;
     }
     registerFile(resource, getContent) {
         this.files.set(( resource.toString()), new File(getContent));
-        return new Disposable$1(() => {
-            this.files.delete(( resource.toString()));
-        });
+        return {
+            dispose: () => {
+                this.files.delete(( resource.toString()));
+            }
+        };
+    }
+    async writeFile() {
+        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
+    }
+    async mkdir() {
+        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
+    }
+    readdir() {
+        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
+    }
+    async delete() {
+        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
+    }
+    async rename() {
+        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
     }
 }
 const extensionFileSystemProvider = new ExtensionFileSystemProviderWithFileReadWriteCapability();
+class OverlayFileSystemProvider {
+    constructor(_default) {
+        this._default = _default;
+        this.others = [];
+        this.onDidChangeCapabilities = Event.any(...( this.delegates.map(delegate => delegate.onDidChangeCapabilities)));
+        this._onDidChangeFile = new Emitter();
+        this.onDidChangeFile = Event.any(this._default.onDidChangeFile, this._onDidChangeFile.event);
+        this.capabilities = 2  | 1024 ;
+        _default.onDidChangeFile((e) => {
+            this._onDidChangeFile.fire(e);
+        });
+    }
+    register(delegate) {
+        this.others.push(delegate);
+        const disposableStore = new DisposableStore();
+        disposableStore.add(delegate.onDidChangeFile(e => {
+            this._onDidChangeFile.fire(e);
+        }));
+        disposableStore.add({
+            dispose: () => {
+                const index = this.others.indexOf(delegate);
+                if (index >= 0) {
+                    this.others.splice(index, 1);
+                }
+            }
+        });
+        return disposableStore;
+    }
+    get delegates() {
+        return [this._default, ...this.others];
+    }
+    async readFromDelegates(caller) {
+        for (const delegate of this.delegates) {
+            try {
+                return await caller(delegate);
+            }
+            catch (err) {
+                if (err instanceof FileSystemProviderError && err.code === FileSystemProviderErrorCode.FileNotFound) {
+                    continue;
+                }
+                throw err;
+            }
+        }
+        throw createFileSystemProviderError('No file system registered', FileSystemProviderErrorCode.FileNotFound);
+    }
+    async writeToDelegates(caller) {
+        await Promise.all(( this.delegates.map(async (delegate) => {
+            if (((delegate.capabilities & 2048) ) === 0) {
+                await caller(delegate);
+            }
+        })));
+    }
+    async stat(resource) {
+        return this.readFromDelegates(delegate => delegate.stat(resource));
+    }
+    async readFile(resource) {
+        return this.readFromDelegates(delegate => delegate.readFile(resource));
+    }
+    async readdir(resource) {
+        return this.readFromDelegates(delegate => delegate.readdir(resource));
+    }
+    watch(resource, opts) {
+        const store = new DisposableStore();
+        for (const delegate of this.delegates) {
+            store.add(delegate.watch(resource, opts));
+        }
+        return store;
+    }
+    async writeFile(resource, content, opts) {
+        await this.writeToDelegates(delegate => delegate.writeFile(resource, content, opts));
+    }
+    async mkdir(resource) {
+        await this.writeToDelegates(delegate => delegate.mkdir(resource));
+    }
+    async delete(resource, opts) {
+        await this.writeToDelegates(delegate => delegate.delete(resource, opts));
+    }
+    async rename(from, to, opts) {
+        await this.writeToDelegates(delegate => delegate.rename(from, to, opts));
+    }
+}
+const fileSystemProvider = new OverlayFileSystemProvider(new InMemoryFileSystemProvider());
 let MemoryFileService = class MemoryFileService extends FileService {
     constructor(logService) {
         super(logService);
-        this.registerProvider('user', new InMemoryFileSystemProvider());
+        const userMemoryFileSystem = new InMemoryFileSystemProvider();
+        this.registerProvider('user', userMemoryFileSystem);
         this.registerProvider('extension', extensionFileSystemProvider);
+        this.registerProvider('cache', new InMemoryFileSystemProvider());
+        this.registerProvider('logs', new InMemoryFileSystemProvider());
+        this.registerProvider('file', fileSystemProvider);
     }
 };
-MemoryFileService = ( __decorate([
+MemoryFileService = __decorate([
     ( __param(0, ILogService))
-], MemoryFileService));
-function registerExtensionFile(extensionLocation, path, getContent) {
-    return extensionFileSystemProvider.registerFile(joinPath(extensionLocation, path), getContent);
-}
+], MemoryFileService);
 function getServiceOverride() {
     return {
         [( IFileService.toString())]: new SyncDescriptor(MemoryFileService),
-        [( IExtensionResourceLoaderService.toString())]: new SyncDescriptor(SimpleExtensionResourceLoaderService),
         [( ITextFileService.toString())]: new SyncDescriptor(BrowserTextFileService)
     };
 }
-export { getServiceOverride as g, registerExtensionFile as r };
+function registerExtensionFile(extensionLocation, path, getContent) {
+    return extensionFileSystemProvider.registerFile(joinPath(extensionLocation, path), getContent);
+}
+function registerFileSystemOverlay(provider) {
+    return fileSystemProvider.register(provider);
+}
+export { FileSystemProviderError, FileSystemProviderErrorCode, SimpleTextFileSystemProvider, getServiceOverride as default, registerExtensionFile, registerFileSystemOverlay };