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

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/monaco.d.ts

@@ -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 } 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,24 @@ 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;
+    constructor();
     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[]>;
+    onDidChangeCapabilities: Event<any>;
+    onDidChangeFile: Event<any>;
+    registerFile(resource: URI, getContent: () => Promise<string | Uint8Array>): 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(): Promise<never>;
+    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,20 +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 { 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 {
+class StaticFile {
     constructor(getContent) {
         this.getContent = getContent;
         this.ctime = Date.now();
@@ -24,90 +26,62 @@ class File {
     }
 }
 const encoder = new TextEncoder();
-const decoder = new TextDecoder();
-class SimpleTextFileSystemProvider {
+class StaticFileSystemProvider extends Disposable {
     constructor() {
+        super();
+        this.capabilities = 2  | 1024  | 2048 ;
         this.onDidChangeCapabilities = Event.None;
-        this.capabilities = 2  | 1024 ;
         this.onDidChangeFile = Event.None;
-        this.onDidWatchError = Event.None;
+        this.files = new Map();
     }
-    async readFile(resource) {
-        try {
-            const content = await this.getFileContent(resource);
-            if (content != null) {
-                return encoder.encode(content);
+    registerFile(resource, getContent) {
+        this.files.set(( resource.toString()), new StaticFile(getContent));
+        return {
+            dispose: () => {
+                this.files.delete(( resource.toString()));
             }
-        }
-        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);
-        }
-    }
-    watch() {
-        return Disposable.None;
+        };
     }
     async stat(resource) {
-        try {
-            const content = await this.getFileContent(resource);
-            if (content != null) {
+        const resourceUri = ( resource.toString(true));
+        const handledUris = Array.from(( this.files.keys()));
+        for (const handledUri of handledUris) {
+            if (handledUri === resourceUri) {
                 return {
+                    ctime: Date.now(),
+                    mtime: Date.now(),
+                    size: 0,
                     type: FileType.File,
-                    size: encoder.encode(content).length,
+                    permissions: FilePermission.Readonly
+                };
+            }
+            else if (handledUri.startsWith(resourceUri + '/')) {
+                return {
                     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 +99,12 @@ 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() {
         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 +112,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 +147,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;
@@ -202,14 +166,8 @@ 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);
-            }
-        })));
-        if (!( results.some(result => result.status === 'fulfilled'))) {
-            throw results[0].reason;
-        }
+        const firstWritableProvider = this.delegates.find(provider => ((provider.capabilities & 2048) ) === 0);
+        return caller(firstWritableProvider);
     }
     async stat(resource) {
         return this.readFromDelegates(delegate => delegate.stat(resource));
@@ -219,7 +177,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()));
@@ -244,7 +202,14 @@ class OverlayFileSystemProvider {
         await this.writeToDelegates(delegate => delegate.rename(from, to, opts));
     }
 }
-const fileSystemProvider = new OverlayFileSystemProvider(new InMemoryFileSystemProvider());
+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 MkdirpOnWriteInMemoryFileSystemProvider());
+const extensionFileSystemProvider = new StaticFileSystemProvider();
 let MemoryFileService = class MemoryFileService extends FileService {
     constructor(logService) {
         super(logService);
@@ -271,8 +236,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

@@ -7,7 +7,7 @@ import { S as ServiceIdentifier, c as IConstructorSignature, I as IInstantiation
 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();
+        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 };