@codingame/monaco-vscode-api 1.79.6 → 1.79.7-next.1

package/dist/event.d.ts

@@ -583,4 +583,4 @@ interface IWaitUntil {
     waitUntil(thenable: Promise<unknown>): void;
 }
 
-export { CancellationToken as C, Disposable as D, Event as E, IReference as I, IDisposable as a, DisposableStore as b, Emitter as c, IWaitUntil as d };
+export { CancellationToken as C, Disposable as D, Event as E, IReference as I, IDisposable as a, Emitter as b, DisposableStore as c, IWaitUntil as d };

package/dist/files.d.ts

@@ -914,4 +914,4 @@ interface ICreateFileOptions {
     readonly overwrite?: boolean;
 }
 
-export { FileSystemProviderCapabilities as F, IFileSystemProviderWithFileReadWriteCapability as I, ReadableStreamEvents as R, VSBuffer as V, IFileSystemProviderWithFileReadStreamCapability as a, IStat as b, FileType as c, IFileReadStreamOptions as d, IFileWriteOptions as e, IFileDeleteOptions as f, IFileOverwriteOptions as g, IWatchOptions as h, IFileChange as i, FileSystemProviderError as j, FileSystemProviderErrorCode as k, FileChangeType as l, FilePermission as m, VSBufferReadable as n, VSBufferReadableStream as o, IFileStatWithMetadata as p, FileOperation as q, ReadableStream as r, IReadFileStreamOptions as s, IWriteFileOptions as t, IBaseFileStatWithMetadata as u, IFileReadLimits as v, IRelativePattern as w, IFileService as x };
+export { FileSystemProviderCapabilities as F, IFileSystemProviderWithFileReadWriteCapability as I, ReadableStreamEvents as R, VSBuffer as V, IStat as a, FileType as b, IFileWriteOptions as c, IFileOverwriteOptions as d, IFileDeleteOptions as e, IFileChange as f, IWatchOptions as g, IFileSystemProviderWithFileReadStreamCapability as h, IFileReadStreamOptions as i, FileSystemProviderError as j, FileSystemProviderErrorCode as k, FileChangeType as l, FilePermission as m, VSBufferReadable as n, VSBufferReadableStream as o, IFileStatWithMetadata as p, FileOperation as q, ReadableStream as r, IReadFileStreamOptions as s, IWriteFileOptions as t, IBaseFileStatWithMetadata as u, IFileReadLimits as v, IRelativePattern as w, IFileService as x };

package/dist/languageFeatures.d.ts

@@ -1,5 +1,5 @@
 import { S as ServiceIdentifier, a as ServicesAccessor, I as IInstantiationService } from './instantiation.js';
-import { E as Event, a as IDisposable, C as CancellationToken, c as Emitter, d as IWaitUntil, D as Disposable } from './event.js';
+import { E as Event, a as IDisposable, C as CancellationToken, b as Emitter, d as IWaitUntil, D as Disposable } from './event.js';
 import { I as IJSONSchema } from './jsonSchema.js';
 import { c as ITextModel, P as Position, R as Range, S as Selection, h as IRange, E as EndOfLineSequence, g as IPosition, i as IMarkdownString, j as ISingleEditOperation, k as EditorAutoIndentStrategy, I as IEditorOptions, l as IEditorModel, m as IDimension, n as ITextEditorModel, o as ITextSnapshot, p as ITextBufferFactory, q as IDiffEditor, r as IBaseTextResourceEditorInput, s as IBaseUntypedEditorInput, t as IResourceEditorInput, u as ITextResourceEditorInput } from './editorBrowser.js';
 import { S as Severity$1 } from './severity.js';

package/dist/monaco.d.ts

@@ -1,7 +1,7 @@
 import * as monaco from 'monaco-editor';
 import { I as IEditorOverrideServices } from './standaloneServices.js';
 import { E as Event, D as Disposable, a as IDisposable, I as IReference } from './event.js';
-export { b as DisposableStore } from './event.js';
+export { c as DisposableStore } from './event.js';
 import { c as ITextModel, d as IModelDecorationOptions, e as IModelDecorationsChangeAccessor, f as IEditorContribution, b as ICodeEditor, g as IPosition } from './editorBrowser.js';
 import { L as LanguageFeatureRegistry, I as ILanguageFeaturesService, F as FoldingRangeProvider, a as ILanguageConfigurationService, b as INotificationService, c as ITextFileEditorModel } from './languageFeatures.js';
 export { C as CommandsRegistry, r as registerColor } from './languageFeatures.js';
@@ -9,7 +9,7 @@ import { a as IContextKeyService } from './contextkey.js';
 import { S as ServiceIdentifier } from './instantiation.js';
 import { I as IJSONSchema } from './jsonSchema.js';
 import { U as URI } from './uri.js';
-import { f as IFileDeleteOptions } from './files.js';
+import { e as IFileDeleteOptions } from './files.js';
 import 'vscode';
 import './themables.js';
 import './severity.js';
@@ -332,6 +332,8 @@ declare function registerJsonSchema(schema: JsonSchema): monaco.IDisposable;
  */
 declare function synchronizeJsonSchemas(): monaco.IDisposable;
 
+declare function registerTypescriptWorkerFileProvider(): IDisposable;
+
 declare function writeFile(uri: URI, content: string): Promise<void>;
 declare function deleteFile(uri: URI, options?: Partial<IFileDeleteOptions>): Promise<void>;
 declare function createModelReference(resource: URI, content?: string): Promise<IReference<ITextFileEditorModel>>;
@@ -342,4 +344,4 @@ declare const Extensions: {
     JSONContribution: string;
 };
 
-export { Extensions, FoldingController, FoldingModel, IJSONContributionRegistry, IJSONSchema, IReference, ITextFileEditorModel, JsonSchema, Registry, createConfiguredDiffEditor, createConfiguredEditor, createModelReference, deleteFile, errorHandler, registerJsonSchema, setCollapseStateForMatchingLines, synchronizeJsonSchemas, writeFile };
+export { Extensions, FoldingController, FoldingModel, IJSONContributionRegistry, IJSONSchema, IReference, ITextFileEditorModel, JsonSchema, Registry, createConfiguredDiffEditor, createConfiguredEditor, createModelReference, deleteFile, errorHandler, registerJsonSchema, registerTypescriptWorkerFileProvider, setCollapseStateForMatchingLines, synchronizeJsonSchemas, writeFile };

package/dist/monaco.js

@@ -38,6 +38,7 @@ import { WorkbenchKeybindingService } from './vscode/vs/workbench/services/keybi
 export { registerJsonSchema, synchronizeJsonSchemas } from './json.js';
 import { createInjectedClass } from './tools/injection.js';
 import './vscode/vs/workbench/contrib/codeEditor/browser/workbenchReferenceSearch.js';
+export { registerTypescriptWorkerFileProvider } from './typescript.js';
 let ExtensionPoints = class ExtensionPoints {
     constructor(instantiationService) {
         this.instantiationService = instantiationService;

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

@@ -1,13 +1,57 @@
 import { U as URI } from '../uri.js';
-import { E as Event, C as CancellationToken, a as IDisposable } from '../event.js';
+import { D as Disposable, E as Event, a as IDisposable, C as CancellationToken, b as Emitter } from '../event.js';
 import { I as IEditorOverrideServices } from '../standaloneServices.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';
+import { I as IFileSystemProviderWithFileReadWriteCapability, F as FileSystemProviderCapabilities, a as IStat, b as FileType, c as IFileWriteOptions, d as IFileOverwriteOptions, e as IFileDeleteOptions, f as IFileChange, g as IWatchOptions, h as IFileSystemProviderWithFileReadStreamCapability, i as IFileReadStreamOptions, R as ReadableStreamEvents } 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>;
@@ -57,24 +101,25 @@ declare class HTMLFileSystemProvider implements IFileSystemProviderWithFileReadW
     private createFileSystemProviderError;
 }
 
-declare abstract class SimpleTextFileSystemProvider implements IFileSystemProviderWithFileReadWriteCapability {
-    onDidChangeCapabilities: Event<any>;
+declare class StaticFileSystemProvider extends Disposable implements IFileSystemProviderWithFileReadWriteCapability {
+    private files;
     capabilities: number;
-    protected abstract getFileContent(resource: URI): Promise<string | undefined>;
-    protected abstract setFileContent(resource: URI, content: string, opts: IFileWriteOptions): Promise<void>;
+    constructor(readonly: boolean);
+    onDidChangeCapabilities: Event<any>;
+    _onDidChangeFile: Emitter<readonly IFileChange[]>;
     onDidChangeFile: Event<readonly IFileChange[]>;
+    registerFile(resource: URI, getContent: () => Promise<string | Uint8Array>, setContent?: (content: string) => Promise<void>): 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;
-    stat(resource: URI): Promise<IStat>;
-    mkdir(): Promise<void>;
-    readdir(): Promise<[string, FileType][]>;
-    delete(): Promise<void>;
-    rename(): Promise<void>;
-    onDidWatchError: Event<any>;
+    writeFile(resource: URI, content: Uint8Array): Promise<void>;
+    mkdir(): Promise<never>;
+    delete(): Promise<never>;
+    rename(): Promise<never>;
 }
 declare function getServiceOverride(): IEditorOverrideServices;
 declare function registerExtensionFile(extensionLocation: URI, path: string, getContent: () => Promise<string | Uint8Array>): IDisposable;
-declare function registerFileSystemOverlay(provider: IFileSystemProviderWithFileReadWriteCapability): IDisposable;
+declare function registerFileSystemOverlay(priority: number, provider: StaticFileSystemProvider): IDisposable;
 
-export { FileSystemProviderCapabilities, FileType, HTMLFileSystemProvider, IFileChange, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProviderWithFileReadWriteCapability, IFileWriteOptions, IStat, IWatchOptions, SimpleTextFileSystemProvider, getServiceOverride as default, registerExtensionFile, registerFileSystemOverlay };
+export { FileSystemProviderCapabilities, FileType, HTMLFileSystemProvider, IFileChange, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProviderWithFileReadWriteCapability, IFileWriteOptions, IStat, IWatchOptions, InMemoryFileSystemProvider, StaticFileSystemProvider, getServiceOverride as default, registerExtensionFile, registerFileSystemOverlay };

package/dist/service-override/files.js

@@ -1,22 +1,25 @@
 import { __decorate, __param } from '../node_modules/tslib/tslib.es6.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 { 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 { FileType } from '../vscode/vs/platform/files/common/files.js';
-export { FileChangeType, FilePermission, FileSystemProviderCapabilities } from '../vscode/vs/platform/files/common/files.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 { 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 } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { extUri, 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 monaco from 'monaco-editor/esm/vs/editor/editor.api.js';
+import * as path from 'monaco-editor/esm/vs/base/common/path.js';
 import '../vscode/vs/workbench/contrib/files/browser/files.contribution.js';
-class File {
-    constructor(getContent) {
+class StaticFile {
+    constructor(getContent, setContent) {
         this.getContent = getContent;
+        this.setContent = setContent;
         this.ctime = Date.now();
         this.mtime = Date.now();
         this.size = 0;
@@ -25,89 +28,76 @@ class File {
 }
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();
-class SimpleTextFileSystemProvider {
-    constructor() {
+class StaticFileSystemProvider extends Disposable {
+    constructor(readonly) {
+        super();
+        this.readonly = readonly;
         this.onDidChangeCapabilities = Event.None;
+        this._onDidChangeFile = new Emitter();
+        this.onDidChangeFile = this._onDidChangeFile.event;
+        this.files = new Map();
         this.capabilities = 2  | 1024 ;
-        this.onDidChangeFile = Event.None;
-        this.onDidWatchError = Event.None;
-    }
-    async readFile(resource) {
-        try {
-            const content = await this.getFileContent(resource);
-            if (content != null) {
-                return encoder.encode(content);
-            }
-        }
-        catch (err) {
-            throw createFileSystemProviderError(err, FileSystemProviderErrorCode.Unknown);
-        }
-        throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
-    }
-    async writeFile(resource, content, opts) {
-        try {
-            await this.setFileContent(resource, decoder.decode(content), opts);
-        }
-        catch (err) {
-            throw createFileSystemProviderError(err, FileSystemProviderErrorCode.Unknown);
+        if (readonly) {
+            this.capabilities |= 2048 ;
         }
     }
-    watch() {
-        return Disposable.None;
+    registerFile(resource, getContent, setContent) {
+        this.files.set(( resource.toString()), new StaticFile(getContent, setContent));
+        this._onDidChangeFile.fire([{
+                resource,
+                type: 1
+            }]);
+        return {
+            dispose: () => {
+                this.files.delete(( resource.toString()));
+                this._onDidChangeFile.fire([{
+                        resource,
+                        type: 2
+                    }]);
+            }
+        };
     }
     async stat(resource) {
-        try {
-            const content = await this.getFileContent(resource);
-            if (content != null) {
+        const resourceUri = ( resource.toString(true));
+        const file = this.files.get(resourceUri);
+        if (file != null) {
+            return {
+                ctime: Date.now(),
+                mtime: Date.now(),
+                size: 0,
+                type: FileType.File,
+                permissions: file.setContent == null || this.readonly ? FilePermission.Readonly : undefined
+            };
+        }
+        const handledUris = Array.from(( this.files.keys()));
+        for (const handledUri of handledUris) {
+            if (handledUri.startsWith(resourceUri + '/')) {
                 return {
-                    type: FileType.File,
-                    size: encoder.encode(content).length,
                     ctime: Date.now(),
-                    mtime: Date.now()
+                    mtime: Date.now(),
+                    size: 0,
+                    type: FileType.Directory
                 };
             }
         }
-        catch (err) {
-            throw createFileSystemProviderError(err, FileSystemProviderErrorCode.Unknown);
-        }
         throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
     }
-    async mkdir() {
-    }
-    async readdir() {
-        return [];
-    }
-    delete() {
-        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
-    }
-    rename() {
-        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
-    }
-}
-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() { }
-}
-class ExtensionFileSystemProviderWithFileReadWriteCapability {
-    constructor() {
-        this.capabilities = 2  | 1024  | 2048 ;
-        this.onDidChangeFile = Event.None;
-        this.onDidChangeCapabilities = Event.None;
-        this.files = new Map();
-    }
-    async stat(resource) {
-        const file = this.files.get(( resource.toString()));
-        if (file != null) {
-            return file;
-        }
-        throw FileSystemProviderError.create('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
+            ]))
+        ];
     }
     async readFile(resource) {
         const file = this.files.get(( resource.toString()));
@@ -125,23 +115,21 @@ class ExtensionFileSystemProviderWithFileReadWriteCapability {
     watch() {
         return Disposable.None;
     }
-    registerFile(resource, getContent) {
-        this.files.set(( resource.toString()), new File(getContent));
-        return {
-            dispose: () => {
-                this.files.delete(( resource.toString()));
-            }
-        };
-    }
-    async writeFile() {
+    async writeFile(resource, content) {
+        const file = this.files.get(( resource.toString()));
+        if (file?.setContent != null) {
+            await file.setContent(decoder.decode(content));
+            this._onDidChangeFile.fire([{
+                    resource,
+                    type: 0
+                }]);
+            return;
+        }
         throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
     }
     async mkdir() {
         throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
     }
-    readdir() {
-        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
-    }
     async delete() {
         throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
     }
@@ -149,32 +137,33 @@ class ExtensionFileSystemProviderWithFileReadWriteCapability {
         throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
     }
 }
-const extensionFileSystemProvider = new ExtensionFileSystemProviderWithFileReadWriteCapability();
 function isFullfiled(result) {
     return result.status === 'fulfilled';
 }
 class OverlayFileSystemProvider {
     constructor(_default) {
         this._default = _default;
-        this.others = [];
-        this.onDidChangeCapabilities = Event.any(...( this.delegates.map(delegate => delegate.onDidChangeCapabilities)));
+        this.providers = [];
+        this.onDidChangeCapabilities = Event.None;
         this._onDidChangeFile = new Emitter();
         this.onDidChangeFile = Event.any(this._default.onDidChangeFile, this._onDidChangeFile.event);
         this._onDidChangeOverlays = new Emitter();
         this.onDidChangeOverlays = this._onDidChangeOverlays.event;
         this.capabilities = 2  | 1024 ;
     }
-    register(delegate) {
-        this.others.push(delegate);
+    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(delegate.onDidChangeFile(e => {
+        disposableStore.add(provider.onDidChangeFile(e => {
             this._onDidChangeFile.fire(e);
         }));
         disposableStore.add({
             dispose: () => {
-                const index = this.others.indexOf(delegate);
+                const index = this.providers.indexOf(item);
                 if (index >= 0) {
-                    this.others.splice(index, 1);
+                    this.providers.splice(index, 1);
                     this._onDidChangeOverlays.fire();
                 }
             }
@@ -183,7 +172,7 @@ class OverlayFileSystemProvider {
         return disposableStore;
     }
     get delegates() {
-        return [this._default, ...this.others];
+        return [...( this.providers.map(({ provider }) => provider)), this._default];
     }
     async readFromDelegates(caller) {
         let firstError;
@@ -201,15 +190,30 @@ class OverlayFileSystemProvider {
         }
         throw firstError;
     }
-    async writeToDelegates(caller) {
-        const results = await Promise.allSettled(( this.delegates.map(async (delegate) => {
-            if (((delegate.capabilities & 2048) ) === 0) {
-                await caller(delegate);
+    async writeToDelegates(resource, caller) {
+        for (const provider of this.delegates) {
+            if (((provider.capabilities & 2048) ) > 0) {
+                continue;
+            }
+            try {
+                const stats = await provider.stat(resource);
+                if (((stats.permissions ?? 0) & FilePermission.Readonly) > 0) {
+                    continue;
+                }
+            }
+            catch (err) {
+            }
+            try {
+                return await caller(provider);
+            }
+            catch (err) {
+                if (err instanceof FileSystemProviderError && err.code === FileSystemProviderErrorCode.NoPermissions) {
+                    continue;
+                }
+                throw err;
             }
-        })));
-        if (!( results.some(result => result.status === 'fulfilled'))) {
-            throw results[0].reason;
         }
+        throw createFileSystemProviderError('File not writable', FileSystemProviderErrorCode.NoPermissions);
     }
     async stat(resource) {
         return this.readFromDelegates(delegate => delegate.stat(resource));
@@ -219,7 +223,7 @@ class OverlayFileSystemProvider {
     }
     async readdir(resource) {
         const results = await Promise.allSettled(( this.delegates.map(delegate => delegate.readdir(resource))));
-        if (!( results.some(result => result.status === 'fulfilled'))) {
+        if (!( results.some(isFullfiled))) {
             throw results[0].reason;
         }
         return Object.entries(Object.fromEntries(( results.filter(isFullfiled).map(result => result.value)).flat()));
@@ -232,19 +236,26 @@ class OverlayFileSystemProvider {
         return store;
     }
     async writeFile(resource, content, opts) {
-        await this.writeToDelegates(delegate => delegate.writeFile(resource, content, opts));
+        await this.writeToDelegates(resource, delegate => delegate.writeFile(resource, content, opts));
     }
     async mkdir(resource) {
-        await this.writeToDelegates(delegate => delegate.mkdir(resource));
+        await this.writeToDelegates(resource, delegate => delegate.mkdir(resource));
     }
     async delete(resource, opts) {
-        await this.writeToDelegates(delegate => delegate.delete(resource, opts));
+        await this.writeToDelegates(resource, delegate => delegate.delete(resource, opts));
     }
     async rename(from, to, opts) {
-        await this.writeToDelegates(delegate => delegate.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);
     }
 }
-const fileSystemProvider = new OverlayFileSystemProvider(new InMemoryFileSystemProvider());
+const fileSystemProvider = new OverlayFileSystemProvider(new MkdirpOnWriteInMemoryFileSystemProvider());
+const extensionFileSystemProvider = new StaticFileSystemProvider(true);
 let MemoryFileService = class MemoryFileService extends FileService {
     constructor(logService) {
         super(logService);
@@ -271,8 +282,7 @@ function getServiceOverride() {
 function registerExtensionFile(extensionLocation, path, getContent) {
     return extensionFileSystemProvider.registerFile(joinPath(extensionLocation, path), getContent);
 }
-function registerFileSystemOverlay(provider) {
-    return fileSystemProvider.register(provider);
+function registerFileSystemOverlay(priority, provider) {
+    return fileSystemProvider.register(priority, provider);
 }
-registerFileSystemOverlay(new TypescriptWorkerFileSystemProvider());
-export { FileType, SimpleTextFileSystemProvider, getServiceOverride as default, registerExtensionFile, registerFileSystemOverlay };
+export { FilePermission, FileType, InMemoryFileSystemProvider, StaticFileSystemProvider, getServiceOverride as default, registerExtensionFile, registerFileSystemOverlay };

package/dist/service-override/output.js

@@ -8,7 +8,7 @@ import { FileLoggerService } from '../vscode/vs/platform/log/common/fileLog.js';
 import '../vscode/vs/workbench/contrib/output/browser/output.contribution.js';
 let _FileLoggerService = class _FileLoggerService extends FileLoggerService {
     constructor(fileService) {
-        super(LogLevel.Info, URI.file('logs.log'), fileService);
+        super(LogLevel.Info, ( URI.from({ scheme: 'logs', path: '/' })), fileService);
     }
 };
 _FileLoggerService = __decorate([

package/dist/services.d.ts

@@ -1,13 +1,13 @@
 /// <reference path="./debugProtocol.d.ts" />
 
-import { E as Event$1, a as IDisposable, C as CancellationToken, D as Disposable, c as Emitter } from './event.js';
+import { E as Event$1, a as IDisposable, C as CancellationToken, D as Disposable, b as Emitter } from './event.js';
 import { i as IMarkdownString, l as IEditorModel, p as ITextBufferFactory, c as ITextModel, v as ITextModelCreationOptions, w as IEditor, q as IDiffEditor, t as IResourceEditorInput, u as ITextResourceEditorInput, I as IEditorOptions, x as IResourceEditorInputIdentifier, h as IRange, g as IPosition, P as Position$1, y as IDocumentDiffProviderOptions, z as IDocumentDiff, A as IChange, b as ICodeEditor, B as IBoundarySashes, O as Orientation, C as IDiffEditor$1, D as IDecorationRenderOptions, d as IModelDecorationOptions } from './editorBrowser.js';
 export { F as ITextModelContentProvider, G as ITextModelService, M as MarkdownStringTrustedOptions } from './editorBrowser.js';
 import { S as ServiceIdentifier, c as IConstructorSignature, I as IInstantiationService, B as BrandedService, a as ServicesAccessor } from './instantiation.js';
 import { d as ILanguageIdCodec, S as SubmenuAction, e as IAction, f as ICommandService, g as IEditorCloseEvent, h as IVisibleEditorPane, E as EditorInput, i as EditorsOrder, j as IEditorIdentifier, k as IEditorGroup, G as GroupIdentifier, l as IEditorPane, m as IUntitledTextResourceEditorInput, n as IResourceDiffEditorInput, o as ITextDiffEditorPane, p as IUntypedEditorInput, q as ICloseEditorOptions, s as IFindEditorOptions, t as IRevertOptions, u as ISaveOptions, v as IGroupModelChangeEvent, w as ColorIdentifier, x as Color, y as LanguageSelector, z as Command, T as TextEdit, A as IInplaceReplaceSupportResult, W as WorkspaceEdit, B as WorkspaceEditMetadata, D as IActionRunner } from './languageFeatures.js';
 export { a7 as DialogType, ad as IBaseDialogOptions, ae as ICheckbox, af as ICheckboxResult, aa as IConfirmDialogArgs, ai as IConfirmation, aj as IConfirmationResult, ah as ICustomDialogMarkdown, ag as ICustomDialogOptions, a6 as IDialogArgs, a9 as IDialogHandler, a8 as IDialogResult, H as IDialogService, K as IEditorGroupsService, ak as IInput, ab as IInputDialogArgs, am as IInputElement, al as IInputResult, a as ILanguageConfigurationService, I as ILanguageFeaturesService, J as IMarkerService, V as INeverShowAgainOptions, X as INotification, Y as INotificationActions, $ as INotificationHandle, Z as INotificationProgress, _ as INotificationProgressProperties, R as INotificationProperties, b as INotificationService, an as IPrompt, ap as IPromptBaseButton, aq as IPromptButton, ar as IPromptCancelButton, a0 as IPromptChoice, a1 as IPromptChoiceWithMenu, ac as IPromptDialogArgs, a2 as IPromptOptions, ao as IPromptResult, as as IPromptResultWithCancel, at as IPromptWithCustomCancel, au as IPromptWithDefaultCancel, a3 as IStatusMessageOptions, M as ITextFileService, N as IWorkingCopyFileService, U as NeverShowAgainScope, a4 as NoOpNotification, a5 as NoOpProgress, P as NotificationMessage, Q as NotificationPriority, O as NotificationsFilter } from './languageFeatures.js';
 import { S as Severity } from './severity.js';
-import { c as FileType, V as VSBuffer, x as IFileService } from './files.js';
+import { b as FileType, V as VSBuffer, x as IFileService } from './files.js';
 import { a as UriComponents, U as URI } from './uri.js';
 import { b as IWorkspaceFolder, I as IAnyWorkspaceIdentifier, c as IWorkspaceContextService } from './workspace.js';
 import { c as IStringDictionary, d as IExtensionInfo, C as ConfigurationScope, E as EditPresentationTypes } from './configurationRegistry.js';

package/dist/typescript.js

@@ -0,0 +1,27 @@
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { registerFileSystemOverlay, StaticFileSystemProvider } from './service-override/files.js';
+class TypescriptWorkerFileSystemProvider extends StaticFileSystemProvider {
+    constructor() {
+        super(true);
+        this.updateLibs = () => {
+            this.libDisposable?.dispose();
+            const disposable = new DisposableStore();
+            for (const [path, lib] of Object.entries(monaco.languages.typescript.typescriptDefaults.getExtraLibs())) {
+                disposable.add(this.registerFile(URI.file(path), async () => lib.content));
+            }
+            for (const [path, lib] of Object.entries(monaco.languages.typescript.javascriptDefaults.getExtraLibs())) {
+                disposable.add(this.registerFile(URI.file(path), async () => lib.content));
+            }
+            this.libDisposable = disposable;
+        };
+        this._register(monaco.languages.typescript.typescriptDefaults.onDidExtraLibsChange(this.updateLibs));
+        this._register(monaco.languages.typescript.javascriptDefaults.onDidExtraLibsChange(this.updateLibs));
+        this.updateLibs();
+    }
+}
+function registerTypescriptWorkerFileProvider() {
+    return registerFileSystemOverlay(0, new TypescriptWorkerFileSystemProvider());
+}
+export { registerTypescriptWorkerFileProvider };