@codingame/monaco-vscode-files-service-override 5.1.2-segmenter.1 → 5.2.0

package/files.js

@@ -7,10 +7,10 @@ import { InMemoryFileSystemProvider } from 'vscode/vscode/vs/platform/files/comm
 export { InMemoryFileSystemProvider } from 'vscode/vscode/vs/platform/files/common/inMemoryFilesystemProvider';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
-import { FileType, FilePermission, createFileSystemProviderError, FileSystemProviderErrorCode, FileSystemProviderError } from 'vscode/vscode/vs/platform/files/common/files';
+import { FileType, FilePermission, createFileSystemProviderError, FileSystemProviderErrorCode, FileSystemProviderError, hasFileReadStreamCapability } from 'vscode/vscode/vs/platform/files/common/files';
 export { FileChangeType, FilePermission, FileSystemProviderCapabilities, FileSystemProviderError, FileSystemProviderErrorCode, FileType } from 'vscode/vscode/vs/platform/files/common/files';
 import { Disposable, DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { extUri, joinPath } from 'vscode/vscode/vs/base/common/resources';
+import { extUri, basename, dirname } from 'vscode/vscode/vs/base/common/resources';
 import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
 import { HTMLFileSystemProvider } from 'vscode/vscode/vs/platform/files/browser/htmlFileSystemProvider';
 export { HTMLFileSystemProvider } from 'vscode/vscode/vs/platform/files/browser/htmlFileSystemProvider';
@@ -26,23 +26,77 @@ import { FilesConfigurationService } from 'vscode/vscode/vs/workbench/services/f
 import { IFilesConfigurationService } from 'vscode/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service';
 import { BrowserElevatedFileService } from './vscode/src/vs/workbench/services/files/browser/elevatedFileService.js';
 import { IElevatedFileService } from 'vscode/vscode/vs/workbench/services/files/common/elevatedFileService.service';
+import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
+import { newWriteableStream } from 'vscode/vscode/vs/base/common/stream';
 import { registerServiceInitializePreParticipant, checkServicesNotInitialized } from 'vscode/lifecycle';
 import { logsPath } from 'vscode/workbench';
 import 'vscode/vscode/vs/workbench/contrib/files/browser/files.contribution._configuration';
 
+class RegisteredDirectory {
+    constructor() {
+        this.type = FileType.Directory;
+        this._onDidChange = new Emitter();
+        this.onDidChange = this._onDidChange.event;
+        this._onDidDelete = new Emitter();
+        this.onDidDelete = this._onDidDelete.event;
+        this.ctime = Date.now();
+        this.mtime = Date.now();
+        this.type = FileType.Directory;
+        this.entries = new Map();
+    }
+    async stats() {
+        return {
+            ctime: this.ctime,
+            mtime: this.mtime,
+            size: 0,
+            type: FileType.Directory
+        };
+    }
+    delete() {
+        this._onDidDelete.fire();
+    }
+    addChild(name, node) {
+        this.entries.set(name, node);
+        this._onDidChange.fire();
+        const disposable = {
+            dispose: () => {
+                this.deleteChild(name);
+            }
+        };
+        node.onDidDelete(() => {
+            disposable.dispose();
+        });
+        return disposable;
+    }
+    deleteChild(name) {
+        if (this.entries.delete(name)) {
+            this.mtime = Date.now();
+            this._onDidChange.fire();
+            if (this.entries.size === 0) {
+                this.delete();
+            }
+            return true;
+        }
+        return false;
+    }
+    getChildren(name) {
+        return this.entries.get(name);
+    }
+    read() {
+        return ( Array.from(this.entries.entries()).map(([name, child]) => [name, child.type]));
+    }
+}
 class RegisteredFile {
     constructor(uri, readonly) {
         this.uri = uri;
         this.readonly = readonly;
+        this.type = FileType.File;
         this._onDidChange = new Emitter();
         this.onDidChange = this._onDidChange.event;
         this._onDidDelete = new Emitter();
         this.onDidDelete = this._onDidDelete.event;
-        this._onDidRename = new Emitter();
-        this.onDidRename = this._onDidRename.event;
         this.ctime = Date.now();
         this.mtime = Date.now();
-        this.type = FileType.File;
         this.onDidChange(() => {
             this.mtime = Date.now();
         });
@@ -56,22 +110,21 @@ class RegisteredFile {
             permissions: this.readonly ? FilePermission.Readonly : undefined
         };
     }
-    async getSize() {
-        return (await this.read()).length;
-    }
     async delete() {
+        if (this.readonly) {
+            throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.FileWriteLocked);
+        }
         this._onDidDelete.fire();
     }
-    async rename(to) {
-        const previousUri = this.uri;
-        this.uri = to;
-        this._onDidRename.fire({ from: previousUri, to });
-    }
 }
 class RegisteredReadOnlyFile extends RegisteredFile {
-    constructor(uri, read) {
+    constructor(uri, read, size) {
         super(uri, true);
         this.read = read;
+        this.size = size;
+    }
+    async getSize() {
+        return this.size;
     }
     write() {
         throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.FileWriteLocked);
@@ -79,14 +132,60 @@ class RegisteredReadOnlyFile extends RegisteredFile {
     async delete() {
         throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.FileWriteLocked);
     }
-    async rename() {
+}
+class RegisteredUriFile extends RegisteredFile {
+    constructor(location, url, metadata) {
+        super(location, true);
+        this.url = url;
+        this.metadata = metadata;
+    }
+    async fetch() {
+        const response = await fetch(this.url, {
+            headers: this.metadata?.mimeType != null
+                ? {
+                    Accept: this.metadata.mimeType
+                }
+                : {}
+        });
+        if (response.status !== 200) {
+            throw new Error(response.statusText);
+        }
+        return response;
+    }
+    async getSize() {
+        return this.metadata?.size ?? 0;
+    }
+    async read() {
+        const response = await this.fetch();
+        return new Uint8Array(await response.arrayBuffer());
+    }
+    async readStream() {
+        const response = await this.fetch();
+        return response.body;
+    }
+    write() {
+        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.FileWriteLocked);
+    }
+    async delete() {
         throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.FileWriteLocked);
     }
 }
+const encoder = new TextEncoder();
+function encode(data) {
+    if (data instanceof Uint8Array) {
+        return data;
+    }
+    else {
+        return encoder.encode(data);
+    }
+}
 class RegisteredMemoryFile extends RegisteredFile {
     constructor(uri, content) {
         super(uri, false);
-        this.content = content;
+        this.content = encode(content);
+    }
+    async getSize() {
+        return this.content.length;
     }
     async read() {
         return this.content;
@@ -96,142 +195,266 @@ class RegisteredMemoryFile extends RegisteredFile {
         this._onDidChange.fire();
     }
 }
-const encoder = new TextEncoder();
-const decoder = new TextDecoder();
 class RegisteredFileSystemProvider extends Disposable {
     constructor(readonly) {
         super();
+        this.memoryFdCounter = 0;
+        this.fdMemory = new Map();
         this.onDidChangeCapabilities = Event.None;
         this._onDidChangeFile = new Emitter();
         this.onDidChangeFile = this._onDidChangeFile.event;
-        this.files = new Map();
-        this.capabilities = 2  | 1024 ;
+        this._bufferedChanges = [];
+        this.rootByAuthority = new Map();
+        this.capabilities = 2  | 1024  | 16 ;
         if (readonly) {
             this.capabilities |= 2048 ;
         }
     }
-    formatUri(uri) {
-        return ( uri.with({ query: null, fragment: null }).toString(true));
+    async open(resource) {
+        const data = await this.readFile(resource);
+        const fd = this.memoryFdCounter++;
+        this.fdMemory.set(fd, data);
+        return fd;
+    }
+    async close(fd) {
+        this.fdMemory.delete(fd);
+    }
+    async read(fd, pos, data, offset, length) {
+        const memory = this.fdMemory.get(fd);
+        if (memory == null) {
+            throw createFileSystemProviderError('No file with that descriptor open', FileSystemProviderErrorCode.Unavailable);
+        }
+        const toWrite = VSBuffer.wrap(memory).slice(pos, pos + length);
+        data.set(toWrite.buffer, offset);
+        return toWrite.byteLength;
+    }
+    write(fd, pos, data, offset, length) {
+        const memory = this.fdMemory.get(fd);
+        if (memory == null) {
+            throw createFileSystemProviderError('No file with that descriptor open', FileSystemProviderErrorCode.Unavailable);
+        }
+        const toWrite = VSBuffer.wrap(data).slice(offset, offset + length);
+        memory.set(toWrite.buffer, pos);
+        return Promise.resolve(toWrite.byteLength);
+    }
+    _lookupRoot(authority) {
+        let root = this.rootByAuthority.get(authority);
+        if (root == null) {
+            root = new RegisteredDirectory();
+            this.rootByAuthority.set(authority, root);
+        }
+        return root;
+    }
+    _lookup(uri, silent) {
+        const parts = uri.path.split('/');
+        const root = this._lookupRoot(uri.authority);
+        let entry = root;
+        for (const part of parts) {
+            if (part.length === 0) {
+                continue;
+            }
+            let child;
+            if (entry instanceof RegisteredDirectory) {
+                child = entry.getChildren(part);
+            }
+            if (child == null) {
+                if (!silent) {
+                    throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
+                }
+                else {
+                    return undefined;
+                }
+            }
+            entry = child;
+        }
+        return entry;
+    }
+    _lookupAsDirectory(uri, silent) {
+        const entry = this._lookup(uri, silent);
+        if (entry instanceof RegisteredDirectory) {
+            return entry;
+        }
+        throw createFileSystemProviderError('file not a directory', FileSystemProviderErrorCode.FileNotADirectory);
+    }
+    _lookupAsFile(uri, silent) {
+        const entry = this._lookup(uri, silent);
+        if (entry != null && entry.type === FileType.File) {
+            return entry;
+        }
+        throw createFileSystemProviderError('file is a directory', FileSystemProviderErrorCode.FileIsADirectory);
     }
     registerFile(file) {
-        this.files.set(this.formatUri(file.uri), file);
-        this._onDidChangeFile.fire([{
-                resource: file.uri,
-                type: 1
-            }]);
+        const parts = file.uri.path.split('/');
+        let directory = this._lookupRoot(file.uri.authority);
+        let uri = file.uri.with({ path: '/' });
+        for (const part of parts.slice(0, -1)) {
+            if (part === '') {
+                continue;
+            }
+            uri = extUri.joinPath(uri, part);
+            let children = directory.getChildren(part);
+            if (children == null) {
+                const newDirectory = this.mkdirSync(uri);
+                children = newDirectory;
+            }
+            if (!(children instanceof RegisteredDirectory)) {
+                throw new Error(`file '${uri.toString()}' is not a directory`);
+            }
+            directory = children;
+        }
+        const name = parts[parts.length - 1];
+        if (directory.getChildren(name) != null) {
+            throw new Error(`file '${uri.toString()}' already exists`);
+        }
         const disposableStore = new DisposableStore();
         disposableStore.add(toDisposable(() => {
-            if (this.files.get(this.formatUri(file.uri)) === file) {
-                this.files.delete(this.formatUri(file.uri));
-                this._onDidChangeFile.fire([{
-                        resource: file.uri,
-                        type: 2
-                    }]);
-            }
+            this._fireSoon({
+                resource: file.uri,
+                type: 2
+            });
         }));
         disposableStore.add(file.onDidDelete(() => {
             disposableStore.dispose();
         }));
         disposableStore.add(file.onDidChange(() => {
-            this._onDidChangeFile.fire([{
-                    resource: file.uri,
-                    type: 0
-                }]);
-        }));
-        disposableStore.add(file.onDidRename(({ from, to }) => {
-            if (this.files.get(this.formatUri(from)) === file) {
-                this.files.delete(this.formatUri(from));
-                this.files.set(this.formatUri(to), file);
-                this._onDidChangeFile.fire([{
-                        resource: from,
-                        type: 2
-                    }, {
-                        resource: to,
-                        type: 1
-                    }]);
-            }
+            this._fireSoon({
+                resource: file.uri,
+                type: 0
+            });
         }));
+        disposableStore.add(directory.addChild(name, file));
+        this._fireSoon({
+            resource: file.uri,
+            type: 1
+        });
         return disposableStore;
     }
     async stat(resource) {
-        const resourceUri = this.formatUri(resource);
-        const file = this.files.get(resourceUri);
-        if (file != null) {
-            return file.stats();
-        }
-        const handledUris = Array.from(( this.files.keys()));
-        for (const handledUri of handledUris) {
-            if (handledUri.startsWith(resourceUri + '/')) {
-                return {
-                    ctime: Date.now(),
-                    mtime: Date.now(),
-                    size: 0,
-                    type: FileType.Directory
-                };
-            }
-        }
-        throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
+        const node = this._lookup(resource, false);
+        return node.stats();
+    }
+    readdirSync(resource) {
+        const directory = this._lookupAsDirectory(resource, false);
+        return directory.read();
     }
     async readdir(resource) {
-        const includedPaths = ( ( Array.from(( this.files.keys()))
-            .map(uri => ( URI.parse(uri))))
-            .filter(uri => uri.authority === resource.authority && uri.path.startsWith(resource.path + '/'))
-            .map(uri => extUri.relativePath(resource, uri)));
-        const files = includedPaths.filter(path => !path.includes('/'));
-        const directories = ( includedPaths.filter(path => path.includes('/')).map(path => path.slice(0, path.indexOf('/'))));
-        return [
-            ...( files.map(path => [
-                path,
-                FileType.File
-            ])),
-            ...( directories.map(path => [
-                path,
-                FileType.Directory
-            ]))
-        ];
+        return this.readdirSync(resource);
     }
     async readFile(resource) {
-        const file = this.files.get(this.formatUri(resource));
-        if (file != null) {
-            const data = await file.read();
-            if (data instanceof Uint8Array) {
-                return data;
+        const file = this._lookupAsFile(resource, false);
+        return await file.read();
+    }
+    readFileStream(resource, opts, token) {
+        const file = this._lookupAsFile(resource, false);
+        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') {
+                    let buffer = await file.read();
+                    if (typeof opts.position === 'number') {
+                        buffer = buffer.slice(opts.position);
+                    }
+                    if (typeof opts.length === 'number') {
+                        buffer = buffer.slice(0, opts.length);
+                    }
+                    stream.end(buffer);
+                }
+                else {
+                    const reader = (await file.readStream()).getReader();
+                    let res = await reader.read();
+                    while (!res.done) {
+                        if (token.isCancellationRequested) {
+                            break;
+                        }
+                        await stream.write(res.value);
+                        if (token.isCancellationRequested) {
+                            break;
+                        }
+                        res = await reader.read();
+                    }
+                    stream.end(undefined);
+                }
             }
-            else {
-                return encoder.encode(data);
+            catch (error) {
+                stream.error(createFileSystemProviderError(error, FileSystemProviderErrorCode.Unknown));
+                stream.end();
             }
-        }
-        throw FileSystemProviderError.create('file not found', FileSystemProviderErrorCode.FileNotFound);
+        })();
+        return stream;
     }
     watch() {
         return Disposable.None;
     }
-    async writeFile(resource, content) {
-        const file = this.files.get(this.formatUri(resource));
-        if (file?.write != null) {
-            await file.write(decoder.decode(content));
-            return;
+    async writeFile(resource, content, opts) {
+        const node = this._lookup(resource, true);
+        if (node != null && !(node instanceof RegisteredFile)) {
+            throw createFileSystemProviderError('file is directory', FileSystemProviderErrorCode.FileIsADirectory);
         }
+        if (node == null) {
+            throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
+        }
+        if (!opts.overwrite) {
+            throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
+        }
+        await node.write(content);
+    }
+    async rename() {
         throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
     }
-    async delete(resource) {
-        const file = this.files.get(this.formatUri(resource));
-        if (file != null) {
-            await file.delete();
-            return;
+    mkdirSync(resource) {
+        if (this._lookup(resource, true) != null) {
+            throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
         }
-        throw createFileSystemProviderError('File not found', FileSystemProviderErrorCode.FileNotFound);
+        const basename$1 = basename(resource);
+        const dirname$1 = dirname(resource);
+        const parent = this._lookupAsDirectory(dirname$1, false);
+        const directory = new RegisteredDirectory();
+        const disposable = new DisposableStore();
+        disposable.add(directory.onDidDelete(() => {
+            disposable.dispose();
+            this._fireSoon({
+                resource,
+                type: 2
+            });
+        }));
+        disposable.add(directory.onDidChange(() => {
+            this._fireSoon({
+                resource,
+                type: 0
+            });
+        }));
+        parent.addChild(basename$1, directory);
+        this._fireSoon({ type: 1 , resource });
+        return directory;
     }
-    async rename(from, to) {
-        const file = this.files.get(this.formatUri(from));
-        if (file != null) {
-            await file.rename(to);
-            return;
+    async mkdir() {
+        throw createFileSystemProviderError('Can\' create a directory', FileSystemProviderErrorCode.NoPermissions);
+    }
+    deleteSync(resource) {
+        const node = this._lookup(resource, true);
+        if (node == null) {
+            throw createFileSystemProviderError('Not found', FileSystemProviderErrorCode.FileNotFound);
+        }
+        else if (node.type === FileType.Directory) {
+            throw createFileSystemProviderError('Can\'t delete a directory', FileSystemProviderErrorCode.NoPermissions);
         }
-        throw createFileSystemProviderError('File not found', FileSystemProviderErrorCode.FileNotFound);
+        node.delete();
     }
-    async mkdir() {
-        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
+    async delete(resource) {
+        this.deleteSync(resource);
+    }
+    _fireSoon(...changes) {
+        this._bufferedChanges.push(...changes);
+        if (this._fireSoonHandle != null) {
+            clearTimeout(this._fireSoonHandle);
+            this._fireSoonHandle = undefined;
+        }
+        this._fireSoonHandle = window.setTimeout(() => {
+            this._onDidChangeFile.fire(this._bufferedChanges);
+            this._bufferedChanges.length = 0;
+        }, 5);
     }
 }
 function isFullfiled(result) {
@@ -245,7 +468,7 @@ class OverlayFileSystemProvider {
         this.onDidChangeFile = this._onDidChangeFile.event;
         this._onDidChangeOverlays = new Emitter();
         this.onDidChangeOverlays = this._onDidChangeOverlays.event;
-        this.capabilities = 2  | 1024 ;
+        this.capabilities = 2  | 1024  | 16 ;
     }
     register(priority, provider) {
         const item = { priority, provider };
@@ -293,6 +516,29 @@ class OverlayFileSystemProvider {
         }
         throw firstError;
     }
+    readFromDelegatesSync(caller) {
+        if (this.delegates.length === 0) {
+            throw createFileSystemProviderError('No delegate', FileSystemProviderErrorCode.Unavailable);
+        }
+        let firstError;
+        for (const delegate of this.delegates) {
+            try {
+                return caller(delegate);
+            }
+            catch (err) {
+                firstError ?? (firstError = err);
+                if (err instanceof FileSystemProviderError && [
+                    FileSystemProviderErrorCode.NoPermissions,
+                    FileSystemProviderErrorCode.FileNotFound,
+                    FileSystemProviderErrorCode.Unavailable
+                ].includes(err.code)) {
+                    continue;
+                }
+                throw err;
+            }
+        }
+        throw firstError;
+    }
     async writeToDelegates(caller) {
         if (this.delegates.length === 0) {
             throw createFileSystemProviderError('No delegate', FileSystemProviderErrorCode.Unavailable);
@@ -330,6 +576,22 @@ class OverlayFileSystemProvider {
     async readFile(resource) {
         return this.readFromDelegates(delegate => delegate.readFile(resource));
     }
+    readFileStream(resource, opts, token) {
+        return this.readFromDelegatesSync(delegate => {
+            if (hasFileReadStreamCapability(delegate)) {
+                return delegate.readFileStream(resource, opts, token);
+            }
+            else {
+                const stream = newWriteableStream(data => VSBuffer.concat(( data.map(data => VSBuffer.wrap(data)))).buffer);
+                delegate.readFile(resource).then(data => {
+                    stream.end(data);
+                }, err => {
+                    stream.error(err);
+                });
+                return stream;
+            }
+        });
+    }
     async readdir(resource) {
         const results = await Promise.allSettled(( this.delegates.map(async (delegate) => delegate.readdir(resource))));
         if (!( results.some(isFullfiled))) {
@@ -496,8 +758,8 @@ function registerCustomProvider(scheme, provider) {
     checkServicesNotInitialized();
     providers[scheme] = provider;
 }
-function registerExtensionFile(extensionLocation, filePath, getContent) {
-    return extensionFileSystemProvider.registerFile(new RegisteredReadOnlyFile(joinPath(extensionLocation, filePath), getContent));
+function registerExtensionFile(file) {
+    return extensionFileSystemProvider.registerFile(file);
 }
 async function initFile(file, content, options) {
     checkServicesNotInitialized();
@@ -575,4 +837,4 @@ function registerFileSystemOverlay(priority, provider) {
     return overlayProvider.register(priority, provider);
 }
 
-export { CustomSchemas, DelegateFileSystemProvider, EmptyFileSystemProvider, IndexedDBFileSystemProvider, OverlayFileSystemProvider, RegisteredFile, RegisteredFileSystemProvider, RegisteredMemoryFile, RegisteredReadOnlyFile, createIndexedDBProviders, getServiceOverride as default, initFile, registerCustomProvider, registerExtensionFile, registerFileSystemOverlay, registerHTMLFileSystemProvider };
+export { CustomSchemas, DelegateFileSystemProvider, EmptyFileSystemProvider, IndexedDBFileSystemProvider, OverlayFileSystemProvider, RegisteredFile, RegisteredFileSystemProvider, RegisteredMemoryFile, RegisteredReadOnlyFile, RegisteredUriFile, createIndexedDBProviders, getServiceOverride as default, initFile, registerCustomProvider, registerExtensionFile, registerFileSystemOverlay, registerHTMLFileSystemProvider };

package/index.js

@@ -1,4 +1,4 @@
-export { CustomSchemas, DelegateFileSystemProvider, EmptyFileSystemProvider, OverlayFileSystemProvider, RegisteredFile, RegisteredFileSystemProvider, RegisteredMemoryFile, RegisteredReadOnlyFile, createIndexedDBProviders, default, initFile, registerCustomProvider, registerExtensionFile, registerFileSystemOverlay, registerHTMLFileSystemProvider } from './files.js';
+export { CustomSchemas, DelegateFileSystemProvider, EmptyFileSystemProvider, OverlayFileSystemProvider, RegisteredFile, RegisteredFileSystemProvider, RegisteredMemoryFile, RegisteredReadOnlyFile, RegisteredUriFile, createIndexedDBProviders, default, initFile, registerCustomProvider, registerExtensionFile, registerFileSystemOverlay, registerHTMLFileSystemProvider } from './files.js';
 export { FileChangeType, FilePermission, FileSystemProviderCapabilities, FileSystemProviderError, FileSystemProviderErrorCode, FileType } from 'vscode/vscode/vs/platform/files/common/files';
 export { HTMLFileSystemProvider } from 'vscode/vscode/vs/platform/files/browser/htmlFileSystemProvider';
 export { InMemoryFileSystemProvider } from 'vscode/vscode/vs/platform/files/common/inMemoryFilesystemProvider';

package/package.json

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