@codingame/monaco-vscode-files-service-override 9.0.2 → 10.0.0

package/files.js

@@ -205,7 +205,10 @@ class RegisteredFileSystemProvider extends Disposable {
         this.onDidChangeFile = this._onDidChangeFile.event;
         this._bufferedChanges = [];
         this.rootByAuthority = new Map();
-        this.capabilities = 2  | 1024  | 16 ;
+        this.capabilities =
+            2  |
+                1024  |
+                16 ;
         if (readonly) {
             this.capabilities |= 2048 ;
         }
@@ -347,12 +350,14 @@ class RegisteredFileSystemProvider extends Disposable {
     }
     readFileStream(resource, opts, token) {
         const file = this._lookupAsFile(resource, false);
-        const stream = newWriteableStream(data => VSBuffer.concat(( data.map(data => VSBuffer.wrap(data)))).buffer, {
+        const stream = newWriteableStream((data) => VSBuffer.concat(( data.map((data) => VSBuffer.wrap(data)))).buffer, {
             highWaterMark: 10
         });
         void (async () => {
             try {
-                if (file.readStream == null || typeof opts.length === 'number' || typeof opts.position === 'number') {
+                if (file.readStream == null ||
+                    typeof opts.length === 'number' ||
+                    typeof opts.position === 'number') {
                     let buffer = await file.read();
                     if (typeof opts.position === 'number' || typeof opts.length === 'number') {
                         buffer = buffer.slice(opts.position ?? 0, opts.length);
@@ -428,7 +433,7 @@ class RegisteredFileSystemProvider extends Disposable {
         return directory;
     }
     async mkdir() {
-        throw createFileSystemProviderError('Can\' create a directory', FileSystemProviderErrorCode.NoPermissions);
+        throw createFileSystemProviderError("Can' create a directory", FileSystemProviderErrorCode.NoPermissions);
     }
     deleteSync(resource) {
         const node = this._lookup(resource, true);
@@ -436,7 +441,7 @@ class RegisteredFileSystemProvider extends Disposable {
             throw createFileSystemProviderError('Not found', FileSystemProviderErrorCode.FileNotFound);
         }
         else if (node.type === FileType.Directory) {
-            throw createFileSystemProviderError('Can\'t delete a directory', FileSystemProviderErrorCode.NoPermissions);
+            throw createFileSystemProviderError("Can't delete a directory", FileSystemProviderErrorCode.NoPermissions);
         }
         node.delete();
     }
@@ -466,14 +471,16 @@ class OverlayFileSystemProvider {
         this.onDidChangeFile = this._onDidChangeFile.event;
         this._onDidChangeOverlays = new Emitter();
         this.onDidChangeOverlays = this._onDidChangeOverlays.event;
-        this.capabilities = 2  | 1024  | 16 ;
+        this.capabilities = 2  |
+            1024  |
+            16 ;
     }
     register(priority, provider) {
         const item = { priority, provider };
         this.providers.push(item);
         this.providers.sort((a, b) => b.priority - a.priority);
         const disposableStore = new DisposableStore();
-        disposableStore.add(provider.onDidChangeFile(e => {
+        disposableStore.add(provider.onDidChangeFile((e) => {
             this._onDidChangeFile.fire(e);
         }));
         disposableStore.add({
@@ -505,11 +512,12 @@ class OverlayFileSystemProvider {
             }
             catch (err) {
                 firstError ?? (firstError = err);
-                if (err instanceof FileSystemProviderError && [
-                    FileSystemProviderErrorCode.NoPermissions,
-                    FileSystemProviderErrorCode.FileNotFound,
-                    FileSystemProviderErrorCode.Unavailable
-                ].includes(err.code)) {
+                if (err instanceof FileSystemProviderError &&
+                    [
+                        FileSystemProviderErrorCode.NoPermissions,
+                        FileSystemProviderErrorCode.FileNotFound,
+                        FileSystemProviderErrorCode.Unavailable
+                    ].includes(err.code)) {
                     continue;
                 }
                 throw err;
@@ -529,11 +537,12 @@ class OverlayFileSystemProvider {
                 return await caller(provider);
             }
             catch (err) {
-                if (err instanceof FileSystemProviderError && [
-                    FileSystemProviderErrorCode.NoPermissions,
-                    FileSystemProviderErrorCode.FileNotFound,
-                    FileSystemProviderErrorCode.Unavailable
-                ].includes(err.code)) {
+                if (err instanceof FileSystemProviderError &&
+                    [
+                        FileSystemProviderErrorCode.NoPermissions,
+                        FileSystemProviderErrorCode.FileNotFound,
+                        FileSystemProviderErrorCode.Unavailable
+                    ].includes(err.code)) {
                     continue;
                 }
                 throw err;
@@ -552,10 +561,10 @@ class OverlayFileSystemProvider {
         });
     }
     async readFile(resource) {
-        return await this.readFromDelegates(delegate => delegate.readFile(resource));
+        return await this.readFromDelegates((delegate) => delegate.readFile(resource));
     }
     readFileStream(resource, opts, token) {
-        const writableStream = newWriteableStream(data => VSBuffer.concat(( data.map(data => VSBuffer.wrap(data)))).buffer);
+        const writableStream = newWriteableStream((data) => VSBuffer.concat(( data.map((data) => VSBuffer.wrap(data)))).buffer);
         this.readFromDelegates(async (delegate) => {
             if (hasFileReadStreamCapability(delegate)) {
                 const stream = delegate.readFileStream(resource, opts, token);
@@ -588,7 +597,7 @@ class OverlayFileSystemProvider {
                 }
                 return writableStream.end(data);
             }
-        }, token).catch(err => {
+        }, token).catch((err) => {
             writableStream.error(err);
         });
         return writableStream;
@@ -598,7 +607,10 @@ class OverlayFileSystemProvider {
         if (!( results.some(isFullfiled))) {
             throw results[0].reason;
         }
-        return Object.entries(Object.fromEntries(( results.filter(isFullfiled).map(result => result.value)).flat()));
+        return Object.entries(Object.fromEntries(( results
+            .filter(isFullfiled)
+            .map((result) => result.value))
+            .flat()));
     }
     watch(resource, opts) {
         const store = new DisposableStore();
@@ -622,13 +634,13 @@ class OverlayFileSystemProvider {
         });
     }
     async mkdir(resource) {
-        await this.writeToDelegates(delegate => delegate.mkdir(resource));
+        await this.writeToDelegates((delegate) => delegate.mkdir(resource));
     }
     async delete(resource, opts) {
-        await this.writeToDelegates(delegate => delegate.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));
+        await this.writeToDelegates((delegate) => delegate.rename(from, to, opts));
     }
 }
 class MkdirpOnWriteInMemoryFileSystemProvider extends InMemoryFileSystemProvider {
@@ -641,7 +653,7 @@ class DelegateFileSystemProvider {
     constructor(options) {
         this.options = options;
         this.onDidChangeCapabilities = this.options.delegate.onDidChangeCapabilities;
-        this.onDidChangeFile = ( Event.map(this.options.delegate.onDidChangeFile, changes => ( changes.map(change => ({
+        this.onDidChangeFile = ( Event.map(this.options.delegate.onDidChangeFile, (changes) => ( changes.map((change) => ({
             type: change.type,
             resource: this.options.fromDeletate(change.resource)
         })))));
@@ -656,7 +668,9 @@ class DelegateFileSystemProvider {
             }
             : undefined;
     }
-    get capabilities() { return this.options.delegate.capabilities; }
+    get capabilities() {
+        return this.options.delegate.capabilities;
+    }
     watch(resource, opts) {
         return this.options.delegate.watch(this.options.toDelegate(resource), opts);
     }
@@ -735,7 +749,7 @@ let FileServiceOverride = class FileServiceOverride extends FileService {
                 });
             }
             if (provider instanceof IndexedDBFileSystemProvider) {
-                this._register(provider.onReportError(e => telemetryService.publicLog2('indexedDBFileSystemProviderError', e)));
+                this._register(provider.onReportError((e) => telemetryService.publicLog2('indexedDBFileSystemProviderError', e)));
             }
         }
     }
@@ -774,7 +788,8 @@ async function initFile(file, content, options) {
             return;
         }
         catch (error) {
-            if (!(error instanceof FileSystemProviderError) || error.code !== FileSystemProviderErrorCode.FileNotFound) {
+            if (!(error instanceof FileSystemProviderError) ||
+                error.code !== FileSystemProviderErrorCode.FileNotFound) {
                 console.error('Unable to check if file exists', error);
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-files-service-override",
-  "version": "9.0.2",
+  "version": "10.0.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -26,6 +26,6 @@
     }
   },
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@9.0.2"
+    "vscode": "npm:@codingame/monaco-vscode-api@10.0.0"
   }
 }

package/vscode/src/vs/platform/files/browser/indexedDBFileSystemProvider.js

@@ -6,17 +6,17 @@ import { ExtUri } from 'vscode/vscode/vs/base/common/resources';
 import { isString } from 'vscode/vscode/vs/base/common/types';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { localize } from 'vscode/vscode/vs/nls';
-import { createFileSystemProviderError, FileSystemProviderErrorCode, FileType, FileSystemProviderCapabilities, FileChangeType, FileSystemProviderError } from 'vscode/vscode/vs/platform/files/common/files';
+import { createFileSystemProviderError, FileSystemProviderErrorCode, FileType, FileSystemProviderError } from 'vscode/vscode/vs/platform/files/common/files';
 import { DBClosedError } from 'vscode/vscode/vs/base/browser/indexedDB';
 import { BroadcastDataChannel } from 'vscode/vscode/vs/base/browser/broadcast';
 
-const ERR_FILE_NOT_FOUND = createFileSystemProviderError(( localize(726, "File does not exist")), FileSystemProviderErrorCode.FileNotFound);
-const ERR_FILE_IS_DIR = createFileSystemProviderError(( localize(727, "File is Directory")), FileSystemProviderErrorCode.FileIsADirectory);
-const ERR_FILE_NOT_DIR = createFileSystemProviderError(( localize(728, "File is not a directory")), FileSystemProviderErrorCode.FileNotADirectory);
-const ERR_DIR_NOT_EMPTY = createFileSystemProviderError(( localize(729, "Directory is not empty")), FileSystemProviderErrorCode.Unknown);
-const ERR_FILE_EXCEEDS_STORAGE_QUOTA = createFileSystemProviderError(( localize(730, "File exceeds available storage quota")), FileSystemProviderErrorCode.FileExceedsStorageQuota);
+const ERR_FILE_NOT_FOUND = createFileSystemProviderError(( localize(595, "File does not exist")), FileSystemProviderErrorCode.FileNotFound);
+const ERR_FILE_IS_DIR = createFileSystemProviderError(( localize(596, "File is Directory")), FileSystemProviderErrorCode.FileIsADirectory);
+const ERR_FILE_NOT_DIR = createFileSystemProviderError(( localize(597, "File is not a directory")), FileSystemProviderErrorCode.FileNotADirectory);
+const ERR_DIR_NOT_EMPTY = createFileSystemProviderError(( localize(598, "Directory is not empty")), FileSystemProviderErrorCode.Unknown);
+const ERR_FILE_EXCEEDS_STORAGE_QUOTA = createFileSystemProviderError(( localize(599, "File exceeds available storage quota")), FileSystemProviderErrorCode.FileExceedsStorageQuota);
 const ERR_UNKNOWN_INTERNAL = (message) => createFileSystemProviderError(( localize(
-    731,
+    600,
     "Internal error occurred in IndexedDB File System Provider. ({0})",
     message
 )), FileSystemProviderErrorCode.Unknown);
@@ -135,8 +135,8 @@ class IndexedDBFileSystemProvider extends Disposable {
         this.scheme = scheme;
         this.indexedDB = indexedDB;
         this.store = store;
-        this.capabilities = FileSystemProviderCapabilities.FileReadWrite
-            | FileSystemProviderCapabilities.PathCaseSensitive;
+        this.capabilities = 2
+            | 1024 ;
         this.onDidChangeCapabilities = Event.None;
         this.extUri = ( (new ExtUri(() => false))) ;
         this._onDidChangeFile = this._register(( (new Emitter())));
@@ -304,7 +304,7 @@ class IndexedDBFileSystemProvider extends Disposable {
         (await this.getFiletree()).delete(resource.path);
         toDelete.forEach(key => this.mtimes.delete(key));
         this.triggerChanges(( (toDelete.map(
-            path => ({ resource: resource.with({ path }), type: FileChangeType.DELETED })
+            path => ({ resource: resource.with({ path }), type: 2  })
         ))));
     }
     async tree(resource) {
@@ -353,7 +353,7 @@ class IndexedDBFileSystemProvider extends Disposable {
             fileTree.add(resource.path, { type: 'file', size: content.byteLength });
             this.mtimes.set(( (resource.toString())), Date.now());
         }
-        this.triggerChanges(( (files.map(([resource]) => ({ resource, type: FileChangeType.UPDATED })))));
+        this.triggerChanges(( (files.map(([resource]) => ({ resource, type: 0  })))));
     }
     async writeMany() {
         if (this.fileWriteBatch.length) {

package/vscode/src/vs/platform/files/common/fileService.js

@@ -13,7 +13,7 @@ import { mark } from 'vscode/vscode/vs/base/common/performance';
 import { isAbsolutePath, extUri, extUriIgnorePathCase } from 'vscode/vscode/vs/base/common/resources';
 import { isReadableStream, peekStream, peekReadable, consumeStream, transform, newWriteableStream, isReadableBufferedStream, listenStream } from 'vscode/vscode/vs/base/common/stream';
 import { localize } from 'vscode/vscode/vs/nls';
-import { FileType, toFileSystemProviderErrorCode, FileSystemProviderErrorCode, FileChangesEvent, FileOperationError, FileOperationResult, hasOpenReadWriteCloseCapability, hasReadWriteCapability, hasFileReadStreamCapability, ensureFileSystemProviderError, FilePermission, FileSystemProviderCapabilities, etag, FileOperationEvent, FileOperation, hasFileAtomicWriteCapability, toFileOperationResult, ETAG_DISABLED, hasFileAtomicReadCapability, NotModifiedSinceFileOperationError, TooLargeFileOperationError, hasFileFolderCopyCapability, hasFileAtomicDeleteCapability, hasFileCloneCapability } from 'vscode/vscode/vs/platform/files/common/files';
+import { FileType, toFileSystemProviderErrorCode, FileSystemProviderErrorCode, FileChangesEvent, FileOperationError, hasOpenReadWriteCloseCapability, hasReadWriteCapability, hasFileReadStreamCapability, ensureFileSystemProviderError, FilePermission, etag, FileOperationEvent, hasFileAtomicWriteCapability, toFileOperationResult, ETAG_DISABLED, hasFileAtomicReadCapability, NotModifiedSinceFileOperationError, TooLargeFileOperationError, hasFileFolderCopyCapability, hasFileAtomicDeleteCapability, hasFileCloneCapability } from 'vscode/vscode/vs/platform/files/common/files';
 import { readFileIntoStream } from './io.js';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { ErrorNoTelemetry } from 'vscode/vscode/vs/base/common/errors';
@@ -34,7 +34,7 @@ async function mkdirp(providerExtUri, provider, directory) {
             const stat = await provider.stat(directory);
             if ((stat.type & FileType.Directory) === 0) {
                 throw ( (new Error(localize(
-                    700,
+                    601,
                     "Unable to create folder '{0}' that already exists but is not a directory",
                     resourceForError(directory)
                 ))));
@@ -149,17 +149,17 @@ let FileService = class FileService extends Disposable {
     async withProvider(resource) {
         if (!isAbsolutePath(resource)) {
             throw ( (new FileOperationError(localize(
-                701,
+                602,
                 "Unable to resolve filesystem provider with relative file path '{0}'",
                 this.resourceForError(resource)
-            ), FileOperationResult.FILE_INVALID_PATH)));
+            ), 8 )));
         }
         await this.activateProvider(resource.scheme);
         const provider = this.provider.get(resource.scheme);
         if (!provider) {
             const error = ( (new ErrorNoTelemetry()));
             error.message = ( localize(
-                702,
+                603,
                 "ENOPRO: No file system provider found for resource '{0}'",
                  (resource.toString())
             ));
@@ -192,10 +192,10 @@ let FileService = class FileService extends Disposable {
         catch (error) {
             if (toFileSystemProviderErrorCode(error) === FileSystemProviderErrorCode.FileNotFound) {
                 throw ( (new FileOperationError(localize(
-                    703,
+                    604,
                     "Unable to resolve nonexistent file '{0}'",
                     this.resourceForError(resource)
-                ), FileOperationResult.FILE_NOT_FOUND)));
+                ), 1 )));
             }
             throw ensureFileSystemProviderError(error);
         }
@@ -236,7 +236,7 @@ let FileService = class FileService extends Disposable {
             mtime: stat.mtime,
             ctime: stat.ctime,
             size: stat.size,
-            readonly: Boolean((stat.permissions ?? 0) & FilePermission.Readonly) || Boolean(provider.capabilities & FileSystemProviderCapabilities.Readonly),
+            readonly: Boolean((stat.permissions ?? 0) & FilePermission.Readonly) || Boolean(provider.capabilities & 2048 ),
             locked: Boolean((stat.permissions ?? 0) & FilePermission.Locked),
             etag: etag({ mtime: stat.mtime, size: stat.size }),
             children: undefined
@@ -303,16 +303,16 @@ let FileService = class FileService extends Disposable {
     async doValidateCreateFile(resource, options) {
         if (!options?.overwrite && (await this.exists(resource))) {
             throw ( (new FileOperationError(localize(
-                704,
+                605,
                 "Unable to create file '{0}' that already exists when overwrite flag is not set",
                 this.resourceForError(resource)
-            ), FileOperationResult.FILE_MODIFIED_SINCE, options)));
+            ), 3 , options)));
         }
     }
     async createFile(resource, bufferOrReadableOrStream = VSBuffer.fromString(''), options) {
         await this.doValidateCreateFile(resource, options);
         const fileStat = await this.writeFile(resource, bufferOrReadableOrStream);
-        this._onDidRunOperation.fire(( (new FileOperationEvent(resource, FileOperation.CREATE, fileStat))));
+        this._onDidRunOperation.fire(( (new FileOperationEvent(resource, 0 , fileStat))));
         return fileStat;
     }
     async writeFile(resource, bufferOrReadableOrStream, options) {
@@ -357,11 +357,11 @@ let FileService = class FileService extends Disposable {
             else {
                 await this.doWriteBuffered(provider, resource, writeFileOptions, bufferOrReadableOrStreamOrBufferedStream instanceof VSBuffer ? bufferToReadable(bufferOrReadableOrStreamOrBufferedStream) : bufferOrReadableOrStreamOrBufferedStream);
             }
-            this._onDidRunOperation.fire(( (new FileOperationEvent(resource, FileOperation.WRITE))));
+            this._onDidRunOperation.fire(( (new FileOperationEvent(resource, 4 ))));
         }
         catch (error) {
             throw ( (new FileOperationError(localize(
-                705,
+                606,
                 "Unable to write file '{0}' ({1})",
                 this.resourceForError(resource),
                 ( (ensureFileSystemProviderError(error).toString()))
@@ -371,32 +371,32 @@ let FileService = class FileService extends Disposable {
     }
     async validateWriteFile(provider, resource, options) {
         const unlock = !!options?.unlock;
-        if (unlock && !(provider.capabilities & FileSystemProviderCapabilities.FileWriteUnlock)) {
+        if (unlock && !((provider.capabilities & 8192) )) {
             throw ( (new Error(localize(
-                706,
+                607,
                 "Unable to unlock file '{0}' because provider does not support it.",
                 this.resourceForError(resource)
             ))));
         }
         const atomic = !!options?.atomic;
         if (atomic) {
-            if (!(provider.capabilities & FileSystemProviderCapabilities.FileAtomicWrite)) {
+            if (!((provider.capabilities & 32768) )) {
                 throw ( (new Error(localize(
-                    707,
+                    608,
                     "Unable to atomically write file '{0}' because provider does not support it.",
                     this.resourceForError(resource)
                 ))));
             }
-            if (!(provider.capabilities & FileSystemProviderCapabilities.FileReadWrite)) {
+            if (!((provider.capabilities & 2) )) {
                 throw ( (new Error(localize(
-                    708,
+                    609,
                     "Unable to atomically write file '{0}' because provider does not support unbuffered writes.",
                     this.resourceForError(resource)
                 ))));
             }
             if (unlock) {
                 throw ( (new Error(localize(
-                    709,
+                    610,
                     "Unable to unlock file '{0}' because atomic write is enabled.",
                     this.resourceForError(resource)
                 ))));
@@ -411,18 +411,18 @@ let FileService = class FileService extends Disposable {
         }
         if ((stat.type & FileType.Directory) !== 0) {
             throw ( (new FileOperationError(localize(
-                710,
+                611,
                 "Unable to write file '{0}' that is actually a directory",
                 this.resourceForError(resource)
-            ), FileOperationResult.FILE_IS_DIRECTORY, options)));
+            ), 0 , options)));
         }
         this.throwIfFileIsReadonly(resource, stat);
         if (typeof options?.mtime === 'number' && typeof options.etag === 'string' && options.etag !== ETAG_DISABLED &&
             typeof stat.mtime === 'number' && typeof stat.size === 'number' &&
             options.mtime < stat.mtime && options.etag !== etag({ mtime: options.mtime , size: stat.size })) {
             throw ( (new FileOperationError(
-                localize(711, "File Modified Since"),
-                FileOperationResult.FILE_MODIFIED_SINCE,
+                localize(612, "File Modified Since"),
+                3 ,
                 options
             )));
         }
@@ -508,7 +508,7 @@ let FileService = class FileService extends Disposable {
     }
     restoreReadError(error, resource, options) {
         const message = ( localize(
-            712,
+            613,
             "Unable to read file '{0}' ({1})",
             this.resourceForError(resource),
              (ensureFileSystemProviderError(error).toString())
@@ -574,13 +574,13 @@ let FileService = class FileService extends Disposable {
         const stat = await this.resolve(resource, { resolveMetadata: true });
         if (stat.isDirectory) {
             throw ( (new FileOperationError(localize(
-                713,
+                614,
                 "Unable to read file '{0}' that is actually a directory",
                 this.resourceForError(resource)
-            ), FileOperationResult.FILE_IS_DIRECTORY, options)));
+            ), 0 , options)));
         }
         if (typeof options?.etag === 'string' && options.etag !== ETAG_DISABLED && options.etag === stat.etag) {
-            throw ( (new NotModifiedSinceFileOperationError(localize(714, "File not modified since"), stat, options)));
+            throw ( (new NotModifiedSinceFileOperationError(localize(615, "File not modified since"), stat, options)));
         }
         this.validateReadFileLimits(resource, stat.size, options);
         return stat;
@@ -588,10 +588,10 @@ let FileService = class FileService extends Disposable {
     validateReadFileLimits(resource, size, options) {
         if (typeof options?.limits?.size === 'number' && size > options.limits.size) {
             throw ( (new TooLargeFileOperationError(localize(
-                715,
+                616,
                 "Unable to read file '{0}' that is too large to open",
                 this.resourceForError(resource)
-            ), FileOperationResult.FILE_TOO_LARGE, size, options)));
+            ), 7 , size, options)));
         }
     }
     async canMove(source, target, overwrite) {
@@ -620,7 +620,7 @@ let FileService = class FileService extends Disposable {
         const fileStat = await this.resolve(target, { resolveMetadata: true });
         this._onDidRunOperation.fire(( (new FileOperationEvent(
             source,
-            mode === 'move' ? FileOperation.MOVE : FileOperation.COPY,
+            mode === 'move' ? 2  : 3 ,
             fileStat
         ))));
         return fileStat;
@@ -632,7 +632,7 @@ let FileService = class FileService extends Disposable {
         const fileStat = await this.resolve(target, { resolveMetadata: true });
         this._onDidRunOperation.fire(( (new FileOperationEvent(
             source,
-            mode === 'copy' ? FileOperation.COPY : FileOperation.MOVE,
+            mode === 'copy' ? 3  : 2 ,
             fileStat
         ))));
         return fileStat;
@@ -710,7 +710,7 @@ let FileService = class FileService extends Disposable {
             }
             if (isSameResourceWithDifferentPathCase && mode === 'copy') {
                 throw ( (new Error(localize(
-                    716,
+                    617,
                     "Unable to copy when source '{0}' is same as target '{1}' with different path case on a case insensitive file system",
                     this.resourceForError(source),
                     this.resourceForError(target)
@@ -718,7 +718,7 @@ let FileService = class FileService extends Disposable {
             }
             if (!isSameResourceWithDifferentPathCase && providerExtUri.isEqualOrParent(target, source)) {
                 throw ( (new Error(localize(
-                    717,
+                    618,
                     "Unable to move/copy when source '{0}' is parent of target '{1}'.",
                     this.resourceForError(source),
                     this.resourceForError(target)
@@ -729,17 +729,17 @@ let FileService = class FileService extends Disposable {
         if (exists && !isSameResourceWithDifferentPathCase) {
             if (!overwrite) {
                 throw ( (new FileOperationError(localize(
-                    718,
+                    619,
                     "Unable to move/copy '{0}' because target '{1}' already exists at destination.",
                     this.resourceForError(source),
                     this.resourceForError(target)
-                ), FileOperationResult.FILE_MOVE_CONFLICT)));
+                ), 4 )));
             }
             if (sourceProvider === targetProvider) {
                 const { providerExtUri } = this.getExtUri(sourceProvider);
                 if (providerExtUri.isEqualOrParent(source, target)) {
                     throw ( (new Error(localize(
-                        719,
+                        620,
                         "Unable to move/copy '{0}' into '{1}' since a file would replace the folder it is contained in.",
                         this.resourceForError(source),
                         this.resourceForError(target)
@@ -757,13 +757,13 @@ let FileService = class FileService extends Disposable {
         };
     }
     isPathCaseSensitive(provider) {
-        return !!(provider.capabilities & FileSystemProviderCapabilities.PathCaseSensitive);
+        return !!((provider.capabilities & 1024) );
     }
     async createFolder(resource) {
         const provider = this.throwIfFileSystemIsReadonly(await this.withProvider(resource), resource);
         await this.mkdirp(provider, resource);
         const fileStat = await this.resolve(resource, { resolveMetadata: true });
-        this._onDidRunOperation.fire(( (new FileOperationEvent(resource, FileOperation.CREATE, fileStat))));
+        this._onDidRunOperation.fire(( (new FileOperationEvent(resource, 0 , fileStat))));
         return fileStat;
     }
     async mkdirp(provider, directory) {
@@ -782,24 +782,24 @@ let FileService = class FileService extends Disposable {
     async doValidateDelete(resource, options) {
         const provider = this.throwIfFileSystemIsReadonly(await this.withProvider(resource), resource);
         const useTrash = !!options?.useTrash;
-        if (useTrash && !(provider.capabilities & FileSystemProviderCapabilities.Trash)) {
+        if (useTrash && !((provider.capabilities & 4096) )) {
             throw ( (new Error(localize(
-                720,
+                621,
                 "Unable to delete file '{0}' via trash because provider does not support it.",
                 this.resourceForError(resource)
             ))));
         }
         const atomic = options?.atomic;
-        if (atomic && !(provider.capabilities & FileSystemProviderCapabilities.FileAtomicDelete)) {
+        if (atomic && !((provider.capabilities & 65536) )) {
             throw ( (new Error(localize(
-                721,
+                622,
                 "Unable to delete file '{0}' atomically because provider does not support it.",
                 this.resourceForError(resource)
             ))));
         }
         if (useTrash && atomic) {
             throw ( (new Error(localize(
-                722,
+                623,
                 "Unable to atomically delete file '{0}' because using trash is enabled.",
                 this.resourceForError(resource)
             ))));
@@ -815,17 +815,17 @@ let FileService = class FileService extends Disposable {
         }
         else {
             throw ( (new FileOperationError(localize(
-                723,
+                624,
                 "Unable to delete nonexistent file '{0}'",
                 this.resourceForError(resource)
-            ), FileOperationResult.FILE_NOT_FOUND)));
+            ), 1 )));
         }
         const recursive = !!options?.recursive;
         if (!recursive) {
             const stat = await this.resolve(resource);
             if (stat.isDirectory && Array.isArray(stat.children) && stat.children.length > 0) {
                 throw ( (new Error(localize(
-                    724,
+                    625,
                     "Unable to delete non-empty folder '{0}'.",
                     this.resourceForError(resource)
                 ))));
@@ -846,7 +846,7 @@ let FileService = class FileService extends Disposable {
         const recursive = !!deleteFileOptions?.recursive;
         const atomic = deleteFileOptions?.atomic ?? false;
         await provider.delete(resource, { recursive, useTrash, atomic });
-        this._onDidRunOperation.fire(( (new FileOperationEvent(resource, FileOperation.DELETE))));
+        this._onDidRunOperation.fire(( (new FileOperationEvent(resource, 1 ))));
     }
     async cloneFile(source, target) {
         const sourceProvider = await this.withProvider(source);
@@ -1084,22 +1084,22 @@ let FileService = class FileService extends Disposable {
         await this.doWriteUnbuffered(targetProvider, target, undefined, buffer);
     }
     throwIfFileSystemIsReadonly(provider, resource) {
-        if (provider.capabilities & FileSystemProviderCapabilities.Readonly) {
+        if (provider.capabilities & 2048 ) {
             throw ( (new FileOperationError(localize(
-                725,
+                626,
                 "Unable to modify read-only file '{0}'",
                 this.resourceForError(resource)
-            ), FileOperationResult.FILE_PERMISSION_DENIED)));
+            ), 6 )));
         }
         return provider;
     }
     throwIfFileIsReadonly(resource, stat) {
         if ((stat.permissions ?? 0) & FilePermission.Readonly) {
             throw ( (new FileOperationError(localize(
-                725,
+                626,
                 "Unable to modify read-only file '{0}'",
                 this.resourceForError(resource)
-            ), FileOperationResult.FILE_PERMISSION_DENIED)));
+            ), 6 )));
         }
     }
     resourceForError(resource) {

package/vscode/src/vs/platform/files/common/io.js

@@ -69,7 +69,7 @@ function throwIfCancelled(token) {
 }
 function throwIfTooLarge(totalBytesRead, options) {
     if (typeof options?.limits?.size === 'number' && totalBytesRead > options.limits.size) {
-        throw createFileSystemProviderError(localize(4503, "File is too large to open"), FileSystemProviderErrorCode.FileTooLarge);
+        throw createFileSystemProviderError(localize(4473, "File is too large to open"), FileSystemProviderErrorCode.FileTooLarge);
     }
     return true;
 }

package/vscode/src/vs/workbench/services/files/browser/elevatedFileService.js

@@ -1,4 +1,3 @@
-import 'vscode/vscode/vs/platform/instantiation/common/extensions';
 import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 
 class BrowserElevatedFileService {

package/vscode/src/vs/workbench/services/textfile/browser/browserTextFileService.js

@@ -1,8 +1,6 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { AbstractTextFileService } from './textFileService.js';
-import { TextFileEditorModelState } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import 'vscode/vscode/vs/platform/instantiation/common/extensions';
 import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
 import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
 import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
@@ -29,7 +27,7 @@ let BrowserTextFileService = class BrowserTextFileService extends AbstractTextFi
         this._register(this.lifecycleService.onBeforeShutdown(event => event.veto(this.onBeforeShutdown(), 'veto.textFiles')));
     }
     onBeforeShutdown() {
-        if (( this.files.models.some(model => model.hasState(TextFileEditorModelState.PENDING_SAVE)))) {
+        if (( this.files.models.some(model => model.hasState(2 )))) {
             return true;
         }
         return false;

package/vscode/src/vs/workbench/services/textfile/browser/textFileService.js

@@ -1,9 +1,8 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { localize } from 'vscode/vscode/vs/nls';
-import { TextFileEditorModelState, TextFileOperationError, TextFileOperationResult, toBufferOrReadable, stringToSnapshot } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
+import { TextFileOperationError, toBufferOrReadable, stringToSnapshot } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
 import { SaveSourceRegistry } from 'vscode/vscode/vs/workbench/common/editor';
 import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
-import { FileOperationResult } from 'vscode/vscode/vs/platform/files/common/files';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { extname } from 'vscode/vscode/vs/base/common/path';
@@ -28,7 +27,7 @@ import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/wor
 import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
 import { WORKSPACE_EXTENSION } from 'vscode/vscode/vs/platform/workspace/common/workspace';
 import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
-import { UTF8, DecodeStreamErrorKind, toEncodeReadable, toDecodeStream, UTF16be, UTF16le, UTF8_with_bom, encodingExists } from 'vscode/vscode/vs/workbench/services/textfile/common/encoding';
+import { UTF8, toEncodeReadable, toDecodeStream, UTF16be, UTF16le, UTF8_with_bom, encodingExists } from 'vscode/vscode/vs/workbench/services/textfile/common/encoding';
 import { consumeStream } from 'vscode/vscode/vs/base/common/stream';
 import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
@@ -48,13 +47,12 @@ import 'vscode/vscode/vs/platform/theme/common/colors/minimapColors';
 import 'vscode/vscode/vs/platform/theme/common/colors/miscColors';
 import 'vscode/vscode/vs/platform/theme/common/colors/quickpickColors';
 import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
-import { firstOrDefault } from 'vscode/vscode/vs/base/common/arrays';
 
 var AbstractTextFileService_1;
 let AbstractTextFileService = class AbstractTextFileService extends Disposable {
     static { AbstractTextFileService_1 = this; }
-    static { this.TEXTFILE_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource('textFileCreate.source', ( localize(4504, "File Created"))); }
-    static { this.TEXTFILE_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource('textFileOverwrite.source', ( localize(4505, "File Replaced"))); }
+    static { this.TEXTFILE_SAVE_CREATE_SOURCE = SaveSourceRegistry.registerSource('textFileCreate.source', ( localize(4474, "File Created"))); }
+    static { this.TEXTFILE_SAVE_REPLACE_SOURCE = SaveSourceRegistry.registerSource('textFileOverwrite.source', ( localize(4475, "File Replaced"))); }
     constructor(fileService, untitledTextEditorService, lifecycleService, instantiationService, modelService, environmentService, dialogService, fileDialogService, textResourceConfigurationService, filesConfigurationService, codeEditorService, pathService, workingCopyFileService, uriIdentityService, languageService, logService, elevatedFileService, decorationsService) {
         super();
         this.fileService = fileService;
@@ -84,14 +82,14 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
             constructor(files) {
                 super();
                 this.files = files;
-                this.label = ( localize(4506, "Text File Model Decorations"));
+                this.label = ( localize(4476, "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(TextFileEditorModelState.ORPHAN)) {
+                    if (model.isReadonly() || model.hasState(4 )) {
                         this._onDidChange.fire([model.resource]);
                     }
                 }));
@@ -105,26 +103,26 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
                     return undefined;
                 }
                 const isReadonly = model.isReadonly();
-                const isOrphaned = model.hasState(TextFileEditorModelState.ORPHAN);
+                const isOrphaned = model.hasState(4 );
                 if (isReadonly && isOrphaned) {
                     return {
                         color: listErrorForeground,
                         letter: Codicon.lockSmall,
                         strikethrough: true,
-                        tooltip: ( localize(4507, "Deleted, Read-only")),
+                        tooltip: ( localize(4477, "Deleted, Read-only")),
                     };
                 }
                 else if (isReadonly) {
                     return {
                         letter: Codicon.lockSmall,
-                        tooltip: ( localize(4508, "Read-only")),
+                        tooltip: ( localize(4478, "Read-only")),
                     };
                 }
                 else if (isOrphaned) {
                     return {
                         color: listErrorForeground,
                         strikethrough: true,
-                        tooltip: ( localize(4509, "Deleted")),
+                        tooltip: ( localize(4479, "Deleted")),
                     };
                 }
                 return undefined;
@@ -176,10 +174,10 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         }
         catch (error) {
             cts.dispose(true);
-            if (error.decodeStreamErrorKind === DecodeStreamErrorKind.STREAM_IS_BINARY) {
+            if (error.decodeStreamErrorKind === 1 ) {
                 throw ( (new TextFileOperationError(
-                    localize(4510, "File seems to be binary and cannot be opened as text"),
-                    TextFileOperationResult.FILE_IS_BINARY,
+                    localize(4480, "File seems to be binary and cannot be opened as text"),
+                    0 ,
                     options
                 )));
             }
@@ -334,8 +332,8 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
             }
             catch (error) {
                 if (targetExists) {
-                    if (error.textFileOperationResult === TextFileOperationResult.FILE_IS_BINARY ||
-                        error.fileOperationResult === FileOperationResult.FILE_TOO_LARGE) {
+                    if (error.textFileOperationResult === 0  ||
+                        error.fileOperationResult === 7 ) {
                         await this.fileService.del(target);
                         return this.doSaveAsTextFile(sourceModel, source, target, options);
                     }
@@ -396,17 +394,17 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         const { confirmed } = await this.dialogService.confirm({
             type: 'warning',
             message: ( localize(
-                4511,
+                4481,
                 "'{0}' already exists. Do you want to replace it?",
                 basename(resource)
             )),
             detail: ( localize(
-                4512,
+                4482,
                 "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(4513, "&&Replace")),
+            primaryButton: ( localize(4483, "&&Replace")),
         });
         return confirmed;
     }
@@ -414,12 +412,12 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         const { confirmed } = await this.dialogService.confirm({
             type: 'warning',
             message: ( localize(
-                4514,
+                4484,
                 "'{0}' is marked as read-only. Do you want to save anyway?",
                 basename(resource)
             )),
-            detail: ( localize(4515, "Paths can be configured as read-only via settings.")),
-            primaryButton: ( localize(4516, "&&Save Anyway"))
+            detail: ( localize(4485, "Paths can be configured as read-only via settings.")),
+            primaryButton: ( localize(4486, "&&Save Anyway"))
         });
         return confirmed;
     }
@@ -467,7 +465,7 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         if (extensions.includes(untitledExtension)) {
             return untitledName;
         }
-        const primaryExtension = firstOrDefault(extensions);
+        const primaryExtension = extensions.at(0);
         if (primaryExtension) {
             if (untitledExtension) {
                 return `${untitledName.substring(0, untitledName.indexOf(untitledExtension))}${primaryExtension}`;
@@ -478,7 +476,7 @@ let AbstractTextFileService = class AbstractTextFileService extends Disposable {
         if (filenames.includes(untitledName)) {
             return untitledName;
         }
-        return firstOrDefault(filenames) ?? untitledName;
+        return filenames.at(0) ?? untitledName;
     }
     async revert(resource, options) {
         if (resource.scheme === Schemas.untitled) {

package/vscode/src/vs/workbench/services/textfile/common/textFileEditorModelManager.js

@@ -7,7 +7,6 @@ import { TextFileEditorModel } from 'vscode/vscode/vs/workbench/services/textfil
 import { Disposable, DisposableStore, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
-import { FileChangeType, FileOperation } from 'vscode/vscode/vs/platform/files/common/files';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
 import { ResourceQueue, Promises } from 'vscode/vscode/vs/base/common/async';
 import { onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
@@ -62,7 +61,7 @@ let TextFileEditorModelManager = class TextFileEditorModelManager extends Dispos
             return {
                 onSaveError(error, model) {
                     notificationService.error(( localize(
-                        9827,
+                        9901,
                         "Failed to save '{0}': {1}",
                         model.name,
                         toErrorMessage(error, false)
@@ -87,7 +86,7 @@ let TextFileEditorModelManager = class TextFileEditorModelManager extends Dispos
             if (model.isDirty()) {
                 continue;
             }
-            if (e.contains(model.resource, FileChangeType.UPDATED, FileChangeType.ADDED)) {
+            if (e.contains(model.resource, 0 , 1 )) {
                 this.queueModelReload(model);
             }
         }
@@ -125,7 +124,7 @@ let TextFileEditorModelManager = class TextFileEditorModelManager extends Dispos
         }
     }
     onWillRunWorkingCopyFileOperation(e) {
-        if (e.operation === FileOperation.MOVE || e.operation === FileOperation.COPY) {
+        if (e.operation === 2  || e.operation === 3 ) {
             const modelsToRestore = [];
             for (const { source, target } of e.files) {
                 if (source) {
@@ -161,7 +160,7 @@ let TextFileEditorModelManager = class TextFileEditorModelManager extends Dispos
         }
     }
     onDidFailWorkingCopyFileOperation(e) {
-        if ((e.operation === FileOperation.MOVE || e.operation === FileOperation.COPY)) {
+        if (((e.operation === 2  || e.operation === 3) )) {
             const modelsToRestore = this.mapCorrelationIdToModelsToRestore.get(e.correlationId);
             if (modelsToRestore) {
                 this.mapCorrelationIdToModelsToRestore.delete(e.correlationId);
@@ -175,7 +174,7 @@ let TextFileEditorModelManager = class TextFileEditorModelManager extends Dispos
     }
     onDidRunWorkingCopyFileOperation(e) {
         switch (e.operation) {
-            case FileOperation.CREATE:
+            case 0 :
                 e.waitUntil((async () => {
                     for (const { target } of e.files) {
                         const model = this.get(target);
@@ -185,8 +184,8 @@ let TextFileEditorModelManager = class TextFileEditorModelManager extends Dispos
                     }
                 })());
                 break;
-            case FileOperation.MOVE:
-            case FileOperation.COPY:
+            case 2 :
+            case 3 :
                 e.waitUntil((async () => {
                     const modelsToRestore = this.mapCorrelationIdToModelsToRestore.get(e.correlationId);
                     if (modelsToRestore) {