@codingame/monaco-vscode-api 1.79.7-next.2 → 1.79.8

package/dist/service-override/editor.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../node_modules/tslib/tslib.es6.js';
-import '../missing-services.js';
+import '../vscode-services/missing-services.js';
 import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
 import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';

package/dist/service-override/files.d.ts

@@ -1,57 +1,13 @@
 import { U as URI } from '../uri.js';
-import { D as Disposable, E as Event, I as IDisposable, C as CancellationToken, a as Emitter } from '../event.js';
+import { E as Event, C as CancellationToken, a as IDisposable } from '../event.js';
 import { I as IEditorOverrideServices } from '../standaloneServices.js';
-import { a as IFileSystemProviderWithFileReadWriteCapability, b as FileSystemProviderCapabilities, c as IStat, F as FileType, d as IFileWriteOptions, e as IFileOverwriteOptions, f as IFileDeleteOptions, g as IFileChange, h as IWatchOptions, i as IFileSystemProviderWithFileReadStreamCapability, j as IFileReadStreamOptions, R as ReadableStreamEvents } from '../files.js';
-export { m as FileChangeType, n as FilePermission, k as FileSystemProviderError, l as FileSystemProviderErrorCode } from '../files.js';
+import { I as IFileSystemProviderWithFileReadWriteCapability, a as IFileSystemProviderWithFileReadStreamCapability, F as FileSystemProviderCapabilities, b as IStat, c as FileType, d as IFileReadStreamOptions, R as ReadableStreamEvents, e as IFileWriteOptions, f as IFileDeleteOptions, g as IFileOverwriteOptions, h as IWatchOptions, i as IFileChange } from '../files.js';
+export { l as FileChangeType, m as FilePermission, j as FileSystemProviderError, k as FileSystemProviderErrorCode } from '../files.js';
 import { I as ILogService } from '../log.js';
 import 'vscode';
 import '../instantiation.js';
 import 'monaco-editor';
 
-declare class File implements IStat {
-    type: FileType.File;
-    ctime: number;
-    mtime: number;
-    size: number;
-    name: string;
-    data?: Uint8Array;
-    constructor(name: string);
-}
-declare class Directory implements IStat {
-    type: FileType.Directory;
-    ctime: number;
-    mtime: number;
-    size: number;
-    name: string;
-    entries: Map<string, File | Directory>;
-    constructor(name: string);
-}
-declare class InMemoryFileSystemProvider extends Disposable implements IFileSystemProviderWithFileReadWriteCapability {
-    private _onDidChangeCapabilities;
-    readonly onDidChangeCapabilities: Event<void>;
-    private _capabilities;
-    get capabilities(): FileSystemProviderCapabilities;
-    setReadOnly(readonly: boolean): void;
-    root: Directory;
-    stat(resource: URI): Promise<IStat>;
-    readdir(resource: URI): Promise<[string, FileType][]>;
-    readFile(resource: URI): Promise<Uint8Array>;
-    writeFile(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;
-    rename(from: URI, to: URI, opts: IFileOverwriteOptions): Promise<void>;
-    delete(resource: URI, opts: IFileDeleteOptions): Promise<void>;
-    mkdir(resource: URI): Promise<void>;
-    private _lookup;
-    private _lookupAsDirectory;
-    private _lookupAsFile;
-    private _lookupParentDirectory;
-    private readonly _onDidChangeFile;
-    readonly onDidChangeFile: Event<readonly IFileChange[]>;
-    private _bufferedChanges;
-    private _fireSoonHandle?;
-    watch(resource: URI, opts: IWatchOptions): IDisposable;
-    private _fireSoon;
-}
-
 declare class IndexedDB {
     private readonly name;
     static create(name: string, version: number | undefined, stores: string[]): Promise<IndexedDB>;
@@ -101,75 +57,24 @@ declare class HTMLFileSystemProvider implements IFileSystemProviderWithFileReadW
     private createFileSystemProviderError;
 }
 
-declare abstract class RegisteredFile {
-    uri: URI;
-    private readonly;
-    private ctime;
-    private mtime;
-    readonly type: FileType;
-    protected _onDidChange: Emitter<void>;
-    onDidChange: Event<void>;
-    protected _onDidDelete: Emitter<void>;
-    onDidDelete: Event<void>;
-    protected _onDidRename: Emitter<{
-        from: URI;
-        to: URI;
-    }>;
-    onDidRename: Event<{
-        from: URI;
-        to: URI;
-    }>;
-    constructor(uri: URI, readonly: boolean);
-    stats(): Promise<IStat>;
-    getSize(): Promise<number>;
-    abstract read(): Promise<string | Uint8Array>;
-    abstract write(content: string): Promise<void>;
-    delete(): Promise<void>;
-    rename(to: URI): Promise<void>;
-}
-declare class RegisteredReadOnlyFile extends RegisteredFile {
-    read: () => Promise<string | Uint8Array>;
-    constructor(uri: URI, read: () => Promise<string | Uint8Array>);
-    write(): Promise<void>;
-    delete(): Promise<void>;
-    rename(): Promise<void>;
-}
-declare class RegisteredMemoryFile extends RegisteredFile {
-    private content;
-    constructor(uri: URI, content: string);
-    read(): Promise<string | Uint8Array>;
-    write(content: string): Promise<void>;
-}
-declare class RegisteredFileSystemProvider extends Disposable implements IFileSystemProviderWithFileReadWriteCapability {
-    private files;
-    capabilities: number;
-    constructor(readonly: boolean);
+declare abstract class SimpleTextFileSystemProvider implements IFileSystemProviderWithFileReadWriteCapability {
     onDidChangeCapabilities: Event<any>;
-    _onDidChangeFile: Emitter<readonly IFileChange[]>;
+    capabilities: number;
+    protected abstract getFileContent(resource: URI): Promise<string | undefined>;
+    protected abstract setFileContent(resource: URI, content: string, opts: IFileWriteOptions): Promise<void>;
     onDidChangeFile: Event<readonly IFileChange[]>;
-    registerFile(file: RegisteredFile): IDisposable;
-    stat(resource: URI): Promise<IStat>;
-    readdir(resource: URI): Promise<[string, FileType][]>;
     readFile(resource: URI): Promise<Uint8Array>;
+    writeFile(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;
     watch(): IDisposable;
-    writeFile(resource: URI, content: Uint8Array): Promise<void>;
-    delete(resource: URI): Promise<void>;
-    rename(from: URI, to: URI): Promise<void>;
-    mkdir(): Promise<never>;
+    stat(resource: URI): Promise<IStat>;
+    mkdir(): Promise<void>;
+    readdir(): Promise<[string, FileType][]>;
+    delete(): Promise<void>;
+    rename(): Promise<void>;
+    onDidWatchError: Event<any>;
 }
 declare function getServiceOverride(): IEditorOverrideServices;
-declare function registerExtensionFile(extensionLocation: URI, filePath: string, getContent: () => Promise<string | Uint8Array>): IDisposable;
-/**
- * Register a file system overlay
- *
- * By default, a memory filesystem is used to read and write file
- *
- * This method allows to register another fileSystemProvider in front OR behind the default memory one.
- *
- * The default one is registered as priority: 0, so:
- * - any provider registered with a positive priority will be in front of the default one
- * - any provider registered with a negative priority will be behind the default one
- */
-declare function registerFileSystemOverlay(priority: number, provider: IFileSystemProviderWithFileReadWriteCapability): IDisposable;
+declare function registerExtensionFile(extensionLocation: URI, path: string, getContent: () => Promise<string | Uint8Array>): IDisposable;
+declare function registerFileSystemOverlay(provider: IFileSystemProviderWithFileReadWriteCapability): IDisposable;
 
-export { FileSystemProviderCapabilities, FileType, HTMLFileSystemProvider, IFileChange, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProviderWithFileReadWriteCapability, IFileWriteOptions, IStat, IWatchOptions, InMemoryFileSystemProvider, RegisteredFile, RegisteredFileSystemProvider, RegisteredMemoryFile, RegisteredReadOnlyFile, getServiceOverride as default, registerExtensionFile, registerFileSystemOverlay };
+export { FileSystemProviderCapabilities, FileType, HTMLFileSystemProvider, IFileChange, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProviderWithFileReadWriteCapability, IFileWriteOptions, IStat, IWatchOptions, SimpleTextFileSystemProvider, getServiceOverride as default, registerExtensionFile, registerFileSystemOverlay };

package/dist/service-override/files.js

@@ -1,179 +1,118 @@
 import { __decorate, __param } from '../node_modules/tslib/tslib.es6.js';
-import '../missing-services.js';
-import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
+import '../vscode-services/missing-services.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 import { FileService } from '../vscode/vs/platform/files/common/fileService.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { InMemoryFileSystemProvider } from '../vscode/vs/platform/files/common/inMemoryFilesystemProvider.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { FileType, FilePermission } from '../vscode/vs/platform/files/common/files.js';
-export { FileChangeType, FileSystemProviderCapabilities } from '../vscode/vs/platform/files/common/files.js';
+import { FileType } from '../vscode/vs/platform/files/common/files.js';
+export { FileChangeType, FilePermission, FileSystemProviderCapabilities } from '../vscode/vs/platform/files/common/files.js';
 import { createFileSystemProviderError, FileSystemProviderErrorCode, FileSystemProviderError, IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 export { FileSystemProviderError, FileSystemProviderErrorCode } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { Disposable, DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { extUri, joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 export { HTMLFileSystemProvider } from 'monaco-editor/esm/vs/platform/files/browser/htmlFileSystemProvider.js';
-import * as path from 'monaco-editor/esm/vs/base/common/path.js';
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api.js';
 import '../vscode/vs/workbench/contrib/files/browser/files.contribution.js';
-class RegisteredFile {
-    constructor(uri, readonly) {
-        this.uri = uri;
-        this.readonly = readonly;
-        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;
+class File {
+    constructor(getContent) {
+        this.getContent = getContent;
         this.ctime = Date.now();
         this.mtime = Date.now();
+        this.size = 0;
         this.type = FileType.File;
     }
-    async stats() {
-        return {
-            ctime: this.ctime,
-            mtime: this.mtime,
-            size: await this.getSize(),
-            type: FileType.File,
-            permissions: this.readonly ? FilePermission.Readonly : undefined
-        };
-    }
-    async getSize() {
-        return (await this.read()).length;
+}
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+class SimpleTextFileSystemProvider {
+    constructor() {
+        this.onDidChangeCapabilities = Event.None;
+        this.capabilities = 2  | 1024 ;
+        this.onDidChangeFile = Event.None;
+        this.onDidWatchError = Event.None;
     }
-    async delete() {
-        this._onDidDelete.fire();
+    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 rename(to) {
-        const previousUri = this.uri;
-        this.uri = to;
-        this._onDidRename.fire({ from: previousUri, to });
+    async writeFile(resource, content, opts) {
+        try {
+            await this.setFileContent(resource, decoder.decode(content), opts);
+        }
+        catch (err) {
+            throw createFileSystemProviderError(err, FileSystemProviderErrorCode.Unknown);
+        }
     }
-}
-class RegisteredReadOnlyFile extends RegisteredFile {
-    constructor(uri, read) {
-        super(uri, true);
-        this.read = read;
+    watch() {
+        return Disposable.None;
     }
-    write() {
-        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.FileWriteLocked);
+    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 delete() {
-        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.FileWriteLocked);
+    async mkdir() {
     }
-    async rename() {
-        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.FileWriteLocked);
+    async readdir() {
+        return [];
     }
-}
-class RegisteredMemoryFile extends RegisteredFile {
-    constructor(uri, content) {
-        super(uri, false);
-        this.content = content;
+    delete() {
+        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
     }
-    async read() {
-        return this.content;
+    rename() {
+        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
     }
-    async write(content) {
-        this.content = content;
-        this._onDidChange.fire();
+}
+class TypescriptWorkerFileSystemProvider extends SimpleTextFileSystemProvider {
+    async getFileContent(resource) {
+        const typescript = monaco.languages.typescript;
+        if (typescript == null) {
+            return undefined;
+        }
+        const path = resource.path.slice(1);
+        return typescript.typescriptDefaults.getExtraLibs()[path]?.content ?? typescript.javascriptDefaults.getExtraLibs()[path]?.content;
     }
+    async setFileContent() { }
 }
-const encoder = new TextEncoder();
-const decoder = new TextDecoder();
-class RegisteredFileSystemProvider extends Disposable {
-    constructor(readonly) {
-        super();
+class ExtensionFileSystemProviderWithFileReadWriteCapability {
+    constructor() {
+        this.capabilities = 2  | 1024  | 2048 ;
+        this.onDidChangeFile = Event.None;
         this.onDidChangeCapabilities = Event.None;
-        this._onDidChangeFile = new Emitter();
-        this.onDidChangeFile = this._onDidChangeFile.event;
         this.files = new Map();
-        this.capabilities = 2  | 1024 ;
-        if (readonly) {
-            this.capabilities |= 2048 ;
-        }
-    }
-    registerFile(file) {
-        this.files.set(( file.uri.toString()), file);
-        this._onDidChangeFile.fire([{
-                resource: file.uri,
-                type: 1
-            }]);
-        const disposableStore = new DisposableStore();
-        disposableStore.add(toDisposable(() => {
-            if (this.files.get(( file.uri.toString())) === file) {
-                this.files.delete(( file.uri.toString()));
-                this._onDidChangeFile.fire([{
-                        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(( from.toString())) === file) {
-                this.files.delete(( from.toString()));
-                this._onDidChangeFile.fire([{
-                        resource: from,
-                        type: 2
-                    }]);
-                this.files.set(( to.toString()), file);
-                this._onDidChangeFile.fire([{
-                        resource: to,
-                        type: 1
-                    }]);
-            }
-        }));
-        return disposableStore;
     }
     async stat(resource) {
-        const resourceUri = ( resource.toString());
-        const file = this.files.get(resourceUri);
+        const file = this.files.get(( resource.toString()));
         if (file != null) {
-            return file.stats();
+            return file;
         }
-        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);
-    }
-    async readdir(resource) {
-        const includedPaths = ( Array.from(( this.files.keys()))
-            .map(uri => path.relative(resource.path, ( URI.parse(uri)).path)))
-            .filter(path => !path.startsWith('..'));
-        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
-            ]))
-        ];
+        throw FileSystemProviderError.create('file not found', FileSystemProviderErrorCode.FileNotFound);
     }
     async readFile(resource) {
         const file = this.files.get(( resource.toString()));
         if (file != null) {
-            const data = await file.read();
+            const data = await file.getContent();
             if (data instanceof Uint8Array) {
                 return data;
             }
@@ -186,60 +125,56 @@ class RegisteredFileSystemProvider extends Disposable {
     watch() {
         return Disposable.None;
     }
-    async writeFile(resource, content) {
-        const file = this.files.get(( resource.toString()));
-        if (file?.write != null) {
-            await file.write(decoder.decode(content));
-            return;
-        }
+    registerFile(resource, getContent) {
+        this.files.set(( resource.toString()), new File(getContent));
+        return {
+            dispose: () => {
+                this.files.delete(( resource.toString()));
+            }
+        };
+    }
+    async writeFile() {
         throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
     }
-    async delete(resource) {
-        const file = this.files.get(( resource.toString()));
-        if (file != null) {
-            await file.delete();
-            return;
-        }
-        throw createFileSystemProviderError('File not found', FileSystemProviderErrorCode.FileNotFound);
+    async mkdir() {
+        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
     }
-    async rename(from, to) {
-        const file = this.files.get(( from.toString()));
-        if (file != null) {
-            await file.rename(to);
-            return;
-        }
-        throw createFileSystemProviderError('File not found', FileSystemProviderErrorCode.FileNotFound);
+    readdir() {
+        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
     }
-    async mkdir() {
+    async delete() {
+        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
+    }
+    async rename() {
         throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
     }
 }
+const extensionFileSystemProvider = new ExtensionFileSystemProviderWithFileReadWriteCapability();
 function isFullfiled(result) {
     return result.status === 'fulfilled';
 }
 class OverlayFileSystemProvider {
-    constructor() {
-        this.providers = [];
-        this.onDidChangeCapabilities = Event.None;
+    constructor(_default) {
+        this._default = _default;
+        this.others = [];
+        this.onDidChangeCapabilities = Event.any(...( this.delegates.map(delegate => delegate.onDidChangeCapabilities)));
         this._onDidChangeFile = new Emitter();
-        this.onDidChangeFile = this._onDidChangeFile.event;
+        this.onDidChangeFile = Event.any(this._default.onDidChangeFile, this._onDidChangeFile.event);
         this._onDidChangeOverlays = new Emitter();
         this.onDidChangeOverlays = this._onDidChangeOverlays.event;
         this.capabilities = 2  | 1024 ;
     }
-    register(priority, provider) {
-        const item = { priority, provider };
-        this.providers.push(item);
-        this.providers.sort((a, b) => b.priority - a.priority);
+    register(delegate) {
+        this.others.push(delegate);
         const disposableStore = new DisposableStore();
-        disposableStore.add(provider.onDidChangeFile(e => {
+        disposableStore.add(delegate.onDidChangeFile(e => {
             this._onDidChangeFile.fire(e);
         }));
         disposableStore.add({
             dispose: () => {
-                const index = this.providers.indexOf(item);
+                const index = this.others.indexOf(delegate);
                 if (index >= 0) {
-                    this.providers.splice(index, 1);
+                    this.others.splice(index, 1);
                     this._onDidChangeOverlays.fire();
                 }
             }
@@ -248,7 +183,7 @@ class OverlayFileSystemProvider {
         return disposableStore;
     }
     get delegates() {
-        return ( this.providers.map(({ provider }) => provider));
+        return [this._default, ...this.others];
     }
     async readFromDelegates(caller) {
         let firstError;
@@ -258,11 +193,7 @@ class OverlayFileSystemProvider {
             }
             catch (err) {
                 firstError ?? (firstError = err);
-                if (err instanceof FileSystemProviderError && [
-                    FileSystemProviderErrorCode.NoPermissions,
-                    FileSystemProviderErrorCode.FileNotFound,
-                    FileSystemProviderErrorCode.Unavailable
-                ].includes(err.code)) {
+                if (err instanceof FileSystemProviderError && err.code === FileSystemProviderErrorCode.FileNotFound) {
                     continue;
                 }
                 throw err;
@@ -270,43 +201,25 @@ class OverlayFileSystemProvider {
         }
         throw firstError;
     }
-    async writeToDelegates(resource, caller) {
-        for (const provider of this.delegates) {
-            if (((provider.capabilities & 2048) ) > 0) {
-                continue;
-            }
-            try {
-                return await caller(provider);
-            }
-            catch (err) {
-                if (err instanceof FileSystemProviderError && [
-                    FileSystemProviderErrorCode.NoPermissions,
-                    FileSystemProviderErrorCode.FileNotFound,
-                    FileSystemProviderErrorCode.Unavailable
-                ].includes(err.code)) {
-                    continue;
-                }
-                throw err;
+    async writeToDelegates(caller) {
+        const results = await Promise.allSettled(( this.delegates.map(async (delegate) => {
+            if (((delegate.capabilities & 2048) ) === 0) {
+                await caller(delegate);
             }
+        })));
+        if (!( results.some(result => result.status === 'fulfilled'))) {
+            throw results[0].reason;
         }
-        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
     }
     async stat(resource) {
-        return this.readFromDelegates(async (delegate) => {
-            const result = await delegate.stat(resource);
-            const readOnly = ((delegate.capabilities & 2048) ) > 0;
-            return {
-                ...result,
-                permissions: result.permissions ?? (readOnly ? FilePermission.Readonly : undefined)
-            };
-        });
+        return this.readFromDelegates(delegate => delegate.stat(resource));
     }
     async readFile(resource) {
         return this.readFromDelegates(delegate => delegate.readFile(resource));
     }
     async readdir(resource) {
         const results = await Promise.allSettled(( this.delegates.map(delegate => delegate.readdir(resource))));
-        if (!( results.some(isFullfiled))) {
+        if (!( results.some(result => result.status === 'fulfilled'))) {
             throw results[0].reason;
         }
         return Object.entries(Object.fromEntries(( results.filter(isFullfiled).map(result => result.value)).flat()));
@@ -319,37 +232,19 @@ class OverlayFileSystemProvider {
         return store;
     }
     async writeFile(resource, content, opts) {
-        await this.writeToDelegates(resource, async (delegate) => {
-            try {
-                const stats = await delegate.stat(resource);
-                if (((stats.permissions ?? 0) & FilePermission.Readonly) > 0) {
-                    throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
-                }
-            }
-            catch (err) {
-            }
-            return delegate.writeFile(resource, content, opts);
-        });
+        await this.writeToDelegates(delegate => delegate.writeFile(resource, content, opts));
     }
     async mkdir(resource) {
-        await this.writeToDelegates(resource, delegate => delegate.mkdir(resource));
+        await this.writeToDelegates(delegate => delegate.mkdir(resource));
     }
     async delete(resource, opts) {
-        await this.writeToDelegates(resource, delegate => delegate.delete(resource, opts));
+        await this.writeToDelegates(delegate => delegate.delete(resource, opts));
     }
     async rename(from, to, opts) {
-        await this.writeToDelegates(from, delegate => delegate.rename(from, to, opts));
-    }
-}
-class MkdirpOnWriteInMemoryFileSystemProvider extends InMemoryFileSystemProvider {
-    async writeFile(resource, content, opts) {
-        await StandaloneServices.get(IFileService)['mkdirp'](this, extUri.dirname(resource));
-        return super.writeFile(resource, content, opts);
+        await this.writeToDelegates(delegate => delegate.rename(from, to, opts));
     }
 }
-const fileSystemProvider = new OverlayFileSystemProvider();
-fileSystemProvider.register(0, new MkdirpOnWriteInMemoryFileSystemProvider());
-const extensionFileSystemProvider = new RegisteredFileSystemProvider(true);
+const fileSystemProvider = new OverlayFileSystemProvider(new InMemoryFileSystemProvider());
 let MemoryFileService = class MemoryFileService extends FileService {
     constructor(logService) {
         super(logService);
@@ -373,10 +268,11 @@ function getServiceOverride() {
         [( IFileService.toString())]: new SyncDescriptor(MemoryFileService)
     };
 }
-function registerExtensionFile(extensionLocation, filePath, getContent) {
-    return extensionFileSystemProvider.registerFile(new RegisteredReadOnlyFile(joinPath(extensionLocation, filePath), getContent));
+function registerExtensionFile(extensionLocation, path, getContent) {
+    return extensionFileSystemProvider.registerFile(joinPath(extensionLocation, path), getContent);
 }
-function registerFileSystemOverlay(priority, provider) {
-    return fileSystemProvider.register(priority, provider);
+function registerFileSystemOverlay(provider) {
+    return fileSystemProvider.register(provider);
 }
-export { FilePermission, FileType, InMemoryFileSystemProvider, RegisteredFile, RegisteredFileSystemProvider, RegisteredMemoryFile, RegisteredReadOnlyFile, getServiceOverride as default, registerExtensionFile, registerFileSystemOverlay };
+registerFileSystemOverlay(new TypescriptWorkerFileSystemProvider());
+export { FileType, SimpleTextFileSystemProvider, getServiceOverride as default, registerExtensionFile, registerFileSystemOverlay };

package/dist/service-override/keybindings.d.ts

@@ -1,5 +1,5 @@
 import { I as IEditorOverrideServices } from '../standaloneServices.js';
-export { c as IUserFriendlyKeybinding } from '../keybinding.js';
+export { I as IUserFriendlyKeybinding } from '../keybinding.js';
 import '../instantiation.js';
 import 'monaco-editor';
 import '../event.js';

package/dist/service-override/keybindings.js

@@ -1,4 +1,4 @@
-import '../missing-services.js';
+import '../vscode-services/missing-services.js';
 import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 import { WorkbenchKeybindingService } from '../vscode/vs/workbench/services/keybinding/browser/keybindingService.js';