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

package/dist/editorBrowser.d.ts

@@ -3711,4 +3711,4 @@ interface IDiffEditor extends IEditor {
     revealFirstDiff(): unknown;
 }
 
-export { IChange as A, IBoundarySashes as B, IDiffEditor as C, IDecorationRenderOptions as D, EndOfLineSequence as E, ITextModelContentProvider as F, ITextModelService as G, IEditorOptions as I, MarkdownStringTrustedOptions as M, Orientation as O, Position as P, Range as R, Selection as S, IResolvedTextEditorModel as a, ICodeEditor as b, ITextModel as c, IModelDecorationOptions as d, IModelDecorationsChangeAccessor as e, IEditorContribution as f, IPosition as g, IRange as h, IMarkdownString as i, ISingleEditOperation as j, EditorAutoIndentStrategy as k, IEditorModel as l, IDimension as m, ITextEditorModel as n, ITextSnapshot as o, ITextBufferFactory as p, IDiffEditor$1 as q, IBaseTextResourceEditorInput as r, IBaseUntypedEditorInput as s, IResourceEditorInput as t, ITextResourceEditorInput as u, ITextModelCreationOptions as v, IEditor as w, IResourceEditorInputIdentifier as x, IDocumentDiffProviderOptions as y, IDocumentDiff as z };
+export { IChange as A, IBoundarySashes as B, IDiffEditor as C, IDecorationRenderOptions as D, EndOfLineSequence as E, ITextModelContentProvider as F, ITextModelService as G, ITextEditorOptions as H, IEditorOptions as I, MarkdownStringTrustedOptions as M, Orientation as O, Position as P, Range as R, Selection as S, IResolvedTextEditorModel as a, ICodeEditor as b, ITextModel as c, IModelDecorationOptions as d, IModelDecorationsChangeAccessor as e, IEditorContribution as f, IPosition as g, IRange as h, IMarkdownString as i, ISingleEditOperation as j, EditorAutoIndentStrategy as k, IEditorModel as l, IDimension as m, ITextEditorModel as n, ITextSnapshot as o, ITextBufferFactory as p, IDiffEditor$1 as q, IBaseTextResourceEditorInput as r, IBaseUntypedEditorInput as s, IResourceEditorInput as t, ITextResourceEditorInput as u, ITextModelCreationOptions as v, IEditor as w, IResourceEditorInputIdentifier as x, IDocumentDiffProviderOptions as y, IDocumentDiff as z };

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, Emitter as b, DisposableStore as c, IWaitUntil as d };
+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 };

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, 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 };
+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 };

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, b as Emitter, d as IWaitUntil, D as Disposable } from './event.js';
+import { E as Event, a as IDisposable, C as CancellationToken, c 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';
@@ -5400,4 +5400,4 @@ interface ILanguageFeaturesService {
     setNotebookTypeResolver(resolver: NotebookInfoResolver | undefined): void;
 }
 
-export { INotificationHandle as $, IInplaceReplaceSupportResult as A, WorkspaceEditMetadata as B, CommandsRegistry as C, IActionRunner as D, EditorInput as E, FoldingRangeProvider as F, GroupIdentifier as G, IDialogService as H, ILanguageFeaturesService as I, IMarkerService as J, IEditorGroupsService as K, LanguageFeatureRegistry as L, ITextFileService as M, IWorkingCopyFileService as N, NotificationsFilter as O, NotificationMessage as P, NotificationPriority as Q, INotificationProperties as R, SubmenuAction as S, TextEdit as T, NeverShowAgainScope as U, INeverShowAgainOptions as V, WorkspaceEdit as W, INotification as X, INotificationActions as Y, INotificationProgress as Z, INotificationProgressProperties as _, ILanguageConfigurationService as a, IPromptChoice as a0, IPromptChoiceWithMenu as a1, IPromptOptions as a2, IStatusMessageOptions as a3, NoOpNotification as a4, NoOpProgress as a5, IDialogArgs as a6, DialogType as a7, IDialogResult as a8, IDialogHandler as a9, IConfirmDialogArgs as aa, IInputDialogArgs as ab, IPromptDialogArgs as ac, IBaseDialogOptions as ad, ICheckbox as ae, ICheckboxResult as af, ICustomDialogOptions as ag, ICustomDialogMarkdown as ah, IConfirmation as ai, IConfirmationResult as aj, IInput as ak, IInputResult as al, IInputElement as am, IPrompt as an, IPromptResult as ao, IPromptBaseButton as ap, IPromptButton as aq, IPromptCancelButton as ar, IPromptResultWithCancel as as, IPromptWithCustomCancel as at, IPromptWithDefaultCancel as au, INotificationService as b, ITextFileEditorModel as c, ILanguageIdCodec as d, IAction as e, ICommandService as f, IEditorCloseEvent as g, IVisibleEditorPane as h, EditorsOrder as i, IEditorIdentifier as j, IEditorGroup as k, IEditorPane as l, IUntitledTextResourceEditorInput as m, IResourceDiffEditorInput as n, ITextDiffEditorPane as o, IUntypedEditorInput as p, ICloseEditorOptions as q, registerColor as r, IFindEditorOptions as s, IRevertOptions as t, ISaveOptions as u, IGroupModelChangeEvent as v, ColorIdentifier as w, Color as x, LanguageSelector as y, Command as z };
+export { IEditorReplacement as $, IInplaceReplaceSupportResult as A, WorkspaceEditMetadata as B, CommandsRegistry as C, IActionRunner as D, EditorInput as E, FoldingRangeProvider as F, GroupIdentifier as G, IDialogService as H, ILanguageFeaturesService as I, IMarkerService as J, IEditorGroupsService as K, LanguageFeatureRegistry as L, GroupDirection as M, GroupOrientation as N, GroupLocation as O, IFindGroupScope as P, GroupsArrangement as Q, GroupLayoutArgument as R, SubmenuAction as S, TextEdit as T, EditorGroupLayout as U, IAddGroupOptions as V, WorkspaceEdit as W, MergeGroupMode as X, IMergeGroupOptions as Y, ICloseEditorsFilter as Z, ICloseAllEditorsOptions as _, ILanguageConfigurationService as a, GroupsOrder as a0, IEditorSideGroup as a1, EditorInputWithOptions as a2, CloseDirection as a3, IEditorPartOptions as a4, IEditorPartOptionsChangeEvent as a5, IEditorWillMoveEvent as a6, IEditorWillOpenEvent as a7, IMatchEditorOptions as a8, IActiveEditorChangeEvent as a9, IPromptDialogArgs as aA, IBaseDialogOptions as aB, ICheckbox as aC, ICheckboxResult as aD, ICustomDialogOptions as aE, ICustomDialogMarkdown as aF, IConfirmation as aG, IConfirmationResult as aH, IInput as aI, IInputResult as aJ, IInputElement as aK, IPrompt as aL, IPromptResult as aM, IPromptBaseButton as aN, IPromptButton as aO, IPromptCancelButton as aP, IPromptResultWithCancel as aQ, IPromptWithCustomCancel as aR, IPromptWithDefaultCancel as aS, IEditorControl as aa, ITextFileService as ab, IWorkingCopyFileService as ac, NotificationsFilter as ad, NotificationMessage as ae, NotificationPriority as af, INotificationProperties as ag, NeverShowAgainScope as ah, INeverShowAgainOptions as ai, INotification as aj, INotificationActions as ak, INotificationProgress as al, INotificationProgressProperties as am, INotificationHandle as an, IPromptChoice as ao, IPromptChoiceWithMenu as ap, IPromptOptions as aq, IStatusMessageOptions as ar, NoOpNotification as as, NoOpProgress as at, IDialogArgs as au, DialogType as av, IDialogResult as aw, IDialogHandler as ax, IConfirmDialogArgs as ay, IInputDialogArgs as az, INotificationService as b, ITextFileEditorModel as c, ILanguageIdCodec as d, IAction as e, ICommandService as f, IEditorCloseEvent as g, IVisibleEditorPane as h, EditorsOrder as i, IEditorIdentifier as j, IEditorGroup as k, IEditorPane as l, IUntitledTextResourceEditorInput as m, IResourceDiffEditorInput as n, ITextDiffEditorPane as o, IUntypedEditorInput as p, ICloseEditorOptions as q, registerColor as r, IFindEditorOptions as s, IRevertOptions as t, ISaveOptions as u, IGroupModelChangeEvent as v, ColorIdentifier as w, Color as x, LanguageSelector as y, Command as z };

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 { c as DisposableStore } from './event.js';
+export { b 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 { e as IFileDeleteOptions } from './files.js';
+import { f as IFileDeleteOptions } from './files.js';
 import 'vscode';
 import './themables.js';
 import './severity.js';
@@ -332,8 +332,6 @@ 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>>;
@@ -344,4 +342,4 @@ declare const Extensions: {
     JSONContribution: string;
 };
 
-export { Extensions, FoldingController, FoldingModel, IJSONContributionRegistry, IJSONSchema, IReference, ITextFileEditorModel, JsonSchema, Registry, createConfiguredDiffEditor, createConfiguredEditor, createModelReference, deleteFile, errorHandler, registerJsonSchema, registerTypescriptWorkerFileProvider, setCollapseStateForMatchingLines, synchronizeJsonSchemas, writeFile };
+export { Extensions, FoldingController, FoldingModel, IJSONContributionRegistry, IJSONSchema, IReference, ITextFileEditorModel, JsonSchema, Registry, createConfiguredDiffEditor, createConfiguredEditor, createModelReference, deleteFile, errorHandler, registerJsonSchema, setCollapseStateForMatchingLines, synchronizeJsonSchemas, writeFile };

package/dist/monaco.js

@@ -38,7 +38,6 @@ 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,57 +1,13 @@
 import { U as URI } from '../uri.js';
-import { D as Disposable, E as Event, a as IDisposable, C as CancellationToken, b 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 { 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';
+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,25 +57,24 @@ declare class HTMLFileSystemProvider implements IFileSystemProviderWithFileReadW
     private createFileSystemProviderError;
 }
 
-declare class StaticFileSystemProvider 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(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;
-    writeFile(resource: URI, content: Uint8Array): Promise<void>;
-    mkdir(): Promise<never>;
-    delete(): Promise<never>;
-    rename(): 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, path: string, getContent: () => Promise<string | Uint8Array>): IDisposable;
-declare function registerFileSystemOverlay(priority: number, provider: StaticFileSystemProvider): IDisposable;
+declare function registerFileSystemOverlay(provider: IFileSystemProviderWithFileReadWriteCapability): IDisposable;
 
-export { FileSystemProviderCapabilities, FileType, HTMLFileSystemProvider, IFileChange, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProviderWithFileReadWriteCapability, IFileWriteOptions, IStat, IWatchOptions, InMemoryFileSystemProvider, StaticFileSystemProvider, 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,25 +1,22 @@
 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 { 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 } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { extUri, joinPath } from 'monaco-editor/esm/vs/base/common/resources.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 StaticFile {
-    constructor(getContent, setContent) {
+class File {
+    constructor(getContent) {
         this.getContent = getContent;
-        this.setContent = setContent;
         this.ctime = Date.now();
         this.mtime = Date.now();
         this.size = 0;
@@ -28,76 +25,89 @@ class StaticFile {
 }
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();
-class StaticFileSystemProvider extends Disposable {
-    constructor(readonly) {
-        super();
-        this.readonly = readonly;
+class SimpleTextFileSystemProvider {
+    constructor() {
         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 ;
-        }
+        this.onDidChangeFile = Event.None;
+        this.onDidWatchError = Event.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 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 stat(resource) {
-        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
-            };
+    async writeFile(resource, content, opts) {
+        try {
+            await this.setFileContent(resource, decoder.decode(content), opts);
         }
-        const handledUris = Array.from(( this.files.keys()));
-        for (const handledUri of handledUris) {
-            if (handledUri.startsWith(resourceUri + '/')) {
+        catch (err) {
+            throw createFileSystemProviderError(err, FileSystemProviderErrorCode.Unknown);
+        }
+    }
+    watch() {
+        return Disposable.None;
+    }
+    async stat(resource) {
+        try {
+            const content = await this.getFileContent(resource);
+            if (content != null) {
                 return {
+                    type: FileType.File,
+                    size: encoder.encode(content).length,
                     ctime: Date.now(),
-                    mtime: Date.now(),
-                    size: 0,
-                    type: FileType.Directory
+                    mtime: Date.now()
                 };
             }
         }
+        catch (err) {
+            throw createFileSystemProviderError(err, FileSystemProviderErrorCode.Unknown);
+        }
         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
-            ]))
-        ];
+    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 readFile(resource) {
         const file = this.files.get(( resource.toString()));
@@ -115,21 +125,23 @@ class StaticFileSystemProvider extends Disposable {
     watch() {
         return Disposable.None;
     }
-    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;
-        }
+    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 mkdir() {
         throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
     }
+    readdir() {
+        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
+    }
     async delete() {
         throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
     }
@@ -137,33 +149,32 @@ class StaticFileSystemProvider extends Disposable {
         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.providers = [];
-        this.onDidChangeCapabilities = Event.None;
+        this.others = [];
+        this.onDidChangeCapabilities = Event.any(...( this.delegates.map(delegate => delegate.onDidChangeCapabilities)));
         this._onDidChangeFile = new Emitter();
         this.onDidChangeFile = Event.any(this._default.onDidChangeFile, this._onDidChangeFile.event);
         this._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();
                 }
             }
@@ -172,7 +183,7 @@ class OverlayFileSystemProvider {
         return disposableStore;
     }
     get delegates() {
-        return [...( this.providers.map(({ provider }) => provider)), this._default];
+        return [this._default, ...this.others];
     }
     async readFromDelegates(caller) {
         let firstError;
@@ -190,30 +201,15 @@ class OverlayFileSystemProvider {
         }
         throw firstError;
     }
-    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;
+    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('File not writable', FileSystemProviderErrorCode.NoPermissions);
     }
     async stat(resource) {
         return this.readFromDelegates(delegate => delegate.stat(resource));
@@ -223,7 +219,7 @@ class OverlayFileSystemProvider {
     }
     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()));
@@ -236,26 +232,19 @@ class OverlayFileSystemProvider {
         return store;
     }
     async writeFile(resource, content, opts) {
-        await this.writeToDelegates(resource, delegate => 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(new MkdirpOnWriteInMemoryFileSystemProvider());
-const extensionFileSystemProvider = new StaticFileSystemProvider(true);
+const fileSystemProvider = new OverlayFileSystemProvider(new InMemoryFileSystemProvider());
 let MemoryFileService = class MemoryFileService extends FileService {
     constructor(logService) {
         super(logService);
@@ -282,7 +271,8 @@ function getServiceOverride() {
 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, StaticFileSystemProvider, getServiceOverride as default, registerExtensionFile, registerFileSystemOverlay };
+registerFileSystemOverlay(new TypescriptWorkerFileSystemProvider());
+export { FileType, SimpleTextFileSystemProvider, 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.from({ scheme: 'logs', path: '/' })), fileService);
+        super(LogLevel.Info, URI.file('logs.log'), fileService);
     }
 };
 _FileLoggerService = __decorate([