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

package/dist/service-override/audioCue.js

@@ -1,4 +1,4 @@
-import '../vscode-services/missing-services.js';
+import '../missing-services.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 import { IAudioCueService, AudioCueService } from 'monaco-editor/esm/vs/platform/audioCues/browser/audioCueService.js';
 import * as _46__46__47__46__46__47_vscode_47_vs_47_platform_47_audioCues_47_browser_47_media_47__42__46_mp3 from './_46__46__47__46__46__47_vscode_47_vs_47_platform_47_audioCues_47_browser_47_media_47__42__46_mp3.js';

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

@@ -1,10 +1,10 @@
 import * as vscode from 'vscode';
 import { U as URI } from '../uri.js';
 import { I as IEditorOverrideServices } from '../standaloneServices.js';
-import { I as IConfigurationRegistry } from '../configurationRegistry.js';
-export { C as ConfigurationScope, b as IConfigurationDefaults, a as IConfigurationNode } from '../configurationRegistry.js';
-export { b as IColorCustomizations, a as IThemeScopedColorCustomizations } from '../workbenchThemeService.js';
-export { I as IAnyWorkspaceIdentifier } from '../workspace.js';
+import { b as IConfigurationRegistry } from '../configurationRegistry.js';
+export { C as ConfigurationScope, d as IConfigurationDefaults, c as IConfigurationNode } from '../configurationRegistry.js';
+export { a as IColorCustomizations, I as IThemeScopedColorCustomizations } from '../workbenchThemeService.js';
+export { a as IAnyWorkspaceIdentifier } from '../workspace.js';
 import '../instantiation.js';
 import 'monaco-editor';
 import '../event.js';

package/dist/service-override/configuration.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../node_modules/tslib/tslib.es6.js';
-import '../vscode-services/missing-services.js';
+import '../missing-services.js';
 import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 import { WorkspaceService } from '../vscode/vs/workbench/services/configuration/browser/configurationService.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';

package/dist/service-override/debug.js

@@ -1,4 +1,4 @@
-import '../vscode-services/missing-services.js';
+import '../missing-services.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 import { IDebugService } from '../vscode/vs/workbench/contrib/debug/common/debug.js';
 import { DebugService } from '../vscode/vs/workbench/contrib/debug/browser/debugService.js';

package/dist/service-override/dialogs.js

@@ -1,4 +1,4 @@
-import '../vscode-services/missing-services.js';
+import '../missing-services.js';
 import '../vscode/vs/workbench/browser/parts/dialogs/dialog.web.contribution.js';
 import { DialogService } from '../vscode/vs/workbench/services/dialogs/common/dialogService.js';
 import { IDialogService, IFileDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';

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

@@ -1,6 +1,6 @@
-export { I as IReference } from '../event.js';
+export { b as IReference } from '../event.js';
 import { I as IEditorOverrideServices } from '../standaloneServices.js';
-export { I as IEditorOptions, a as IResolvedTextEditorModel } from '../editorBrowser.js';
+export { i as IEditorOptions, w as IResolvedTextEditorModel } from '../editorBrowser.js';
 import { O as OpenEditor } from '../editor.js';
 import 'vscode';
 import '../instantiation.js';

package/dist/service-override/editor.js

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

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

@@ -1,8 +1,8 @@
 import { U as URI } from '../uri.js';
-import { D as Disposable, E as Event, a as IDisposable, C as CancellationToken } from '../event.js';
+import { D as Disposable, E as Event, I as IDisposable, C as CancellationToken, a as Emitter } 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';
-export { l as FileChangeType, m as FilePermission, j as FileSystemProviderError, k as FileSystemProviderErrorCode } from '../files.js';
+import { a as IFileSystemProviderWithFileReadWriteCapability, b as FileSystemProviderCapabilities, c as IStat, F as FileType, d as IFileWriteOptions, e as IFileOverwriteOptions, f as IFileDeleteOptions, g as IFileChange, h as IWatchOptions, i as IFileSystemProviderWithFileReadStreamCapability, j as IFileReadStreamOptions, R as ReadableStreamEvents } from '../files.js';
+export { m as FileChangeType, n as FilePermission, k as FileSystemProviderError, l as FileSystemProviderErrorCode } from '../files.js';
 import { I as ILogService } from '../log.js';
 import 'vscode';
 import '../instantiation.js';
@@ -101,24 +101,75 @@ declare class HTMLFileSystemProvider implements IFileSystemProviderWithFileReadW
     private createFileSystemProviderError;
 }
 
-declare class StaticFileSystemProvider extends Disposable implements IFileSystemProviderWithFileReadWriteCapability {
+declare abstract class RegisteredFile {
+    uri: URI;
+    private readonly;
+    private ctime;
+    private mtime;
+    readonly type: FileType;
+    protected _onDidChange: Emitter<void>;
+    onDidChange: Event<void>;
+    protected _onDidDelete: Emitter<void>;
+    onDidDelete: Event<void>;
+    protected _onDidRename: Emitter<{
+        from: URI;
+        to: URI;
+    }>;
+    onDidRename: Event<{
+        from: URI;
+        to: URI;
+    }>;
+    constructor(uri: URI, readonly: boolean);
+    stats(): Promise<IStat>;
+    getSize(): Promise<number>;
+    abstract read(): Promise<string | Uint8Array>;
+    abstract write(content: string): Promise<void>;
+    delete(): Promise<void>;
+    rename(to: URI): Promise<void>;
+}
+declare class RegisteredReadOnlyFile extends RegisteredFile {
+    read: () => Promise<string | Uint8Array>;
+    constructor(uri: URI, read: () => Promise<string | Uint8Array>);
+    write(): Promise<void>;
+    delete(): Promise<void>;
+    rename(): Promise<void>;
+}
+declare class RegisteredMemoryFile extends RegisteredFile {
+    private content;
+    constructor(uri: URI, content: string);
+    read(): Promise<string | Uint8Array>;
+    write(content: string): Promise<void>;
+}
+declare class RegisteredFileSystemProvider extends Disposable implements IFileSystemProviderWithFileReadWriteCapability {
     private files;
-    constructor();
     capabilities: number;
+    constructor(readonly: boolean);
     onDidChangeCapabilities: Event<any>;
-    onDidChangeFile: Event<any>;
-    registerFile(resource: URI, getContent: () => Promise<string | Uint8Array>): IDisposable;
+    _onDidChangeFile: Emitter<readonly IFileChange[]>;
+    onDidChangeFile: Event<readonly IFileChange[]>;
+    registerFile(file: RegisteredFile): IDisposable;
     stat(resource: URI): Promise<IStat>;
     readdir(resource: URI): Promise<[string, FileType][]>;
     readFile(resource: URI): Promise<Uint8Array>;
     watch(): IDisposable;
-    writeFile(): Promise<never>;
+    writeFile(resource: URI, content: Uint8Array): Promise<void>;
+    delete(resource: URI): Promise<void>;
+    rename(from: URI, to: URI): 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(priority: number, provider: StaticFileSystemProvider): IDisposable;
+declare function registerExtensionFile(extensionLocation: URI, filePath: string, getContent: () => Promise<string | Uint8Array>): IDisposable;
+/**
+ * Register a file system overlay
+ *
+ * By default, a memory filesystem is used to read and write file
+ *
+ * This method allows to register another fileSystemProvider in front OR behind the default memory one.
+ *
+ * The default one is registered as priority: 0, so:
+ * - any provider registered with a positive priority will be in front of the default one
+ * - any provider registered with a negative priority will be behind the default one
+ */
+declare function registerFileSystemOverlay(priority: number, provider: IFileSystemProviderWithFileReadWriteCapability): IDisposable;
 
-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, InMemoryFileSystemProvider, RegisteredFile, RegisteredFileSystemProvider, RegisteredMemoryFile, RegisteredReadOnlyFile, getServiceOverride as default, registerExtensionFile, registerFileSystemOverlay };

package/dist/service-override/files.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../node_modules/tslib/tslib.es6.js';
-import '../vscode-services/missing-services.js';
+import '../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';
@@ -10,52 +10,139 @@ import { FileType, FilePermission } from '../vscode/vs/platform/files/common/fil
 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 { Disposable, DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { extUri, joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Emitter, Event } 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 '../vscode/vs/workbench/contrib/files/browser/files.contribution.js';
-class StaticFile {
-    constructor(getContent) {
-        this.getContent = getContent;
+class RegisteredFile {
+    constructor(uri, readonly) {
+        this.uri = uri;
+        this.readonly = readonly;
+        this._onDidChange = new Emitter();
+        this.onDidChange = this._onDidChange.event;
+        this._onDidDelete = new Emitter();
+        this.onDidDelete = this._onDidDelete.event;
+        this._onDidRename = new Emitter();
+        this.onDidRename = this._onDidRename.event;
         this.ctime = Date.now();
         this.mtime = Date.now();
-        this.size = 0;
         this.type = FileType.File;
     }
+    async stats() {
+        return {
+            ctime: this.ctime,
+            mtime: this.mtime,
+            size: await this.getSize(),
+            type: FileType.File,
+            permissions: this.readonly ? FilePermission.Readonly : undefined
+        };
+    }
+    async getSize() {
+        return (await this.read()).length;
+    }
+    async delete() {
+        this._onDidDelete.fire();
+    }
+    async rename(to) {
+        const previousUri = this.uri;
+        this.uri = to;
+        this._onDidRename.fire({ from: previousUri, to });
+    }
+}
+class RegisteredReadOnlyFile extends RegisteredFile {
+    constructor(uri, read) {
+        super(uri, true);
+        this.read = read;
+    }
+    write() {
+        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.FileWriteLocked);
+    }
+    async delete() {
+        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.FileWriteLocked);
+    }
+    async rename() {
+        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.FileWriteLocked);
+    }
+}
+class RegisteredMemoryFile extends RegisteredFile {
+    constructor(uri, content) {
+        super(uri, false);
+        this.content = content;
+    }
+    async read() {
+        return this.content;
+    }
+    async write(content) {
+        this.content = content;
+        this._onDidChange.fire();
+    }
 }
 const encoder = new TextEncoder();
-class StaticFileSystemProvider extends Disposable {
-    constructor() {
+const decoder = new TextDecoder();
+class RegisteredFileSystemProvider extends Disposable {
+    constructor(readonly) {
         super();
-        this.capabilities = 2  | 1024  | 2048 ;
         this.onDidChangeCapabilities = Event.None;
-        this.onDidChangeFile = Event.None;
+        this._onDidChangeFile = new Emitter();
+        this.onDidChangeFile = this._onDidChangeFile.event;
         this.files = new Map();
+        this.capabilities = 2  | 1024 ;
+        if (readonly) {
+            this.capabilities |= 2048 ;
+        }
     }
-    registerFile(resource, getContent) {
-        this.files.set(( resource.toString()), new StaticFile(getContent));
-        return {
-            dispose: () => {
-                this.files.delete(( resource.toString()));
+    registerFile(file) {
+        this.files.set(( file.uri.toString()), file);
+        this._onDidChangeFile.fire([{
+                resource: file.uri,
+                type: 1
+            }]);
+        const disposableStore = new DisposableStore();
+        disposableStore.add(toDisposable(() => {
+            if (this.files.get(( file.uri.toString())) === file) {
+                this.files.delete(( file.uri.toString()));
+                this._onDidChangeFile.fire([{
+                        resource: file.uri,
+                        type: 2
+                    }]);
             }
-        };
+        }));
+        disposableStore.add(file.onDidDelete(() => {
+            disposableStore.dispose();
+        }));
+        disposableStore.add(file.onDidChange(() => {
+            this._onDidChangeFile.fire([{
+                    resource: file.uri,
+                    type: 0
+                }]);
+        }));
+        disposableStore.add(file.onDidRename(({ from, to }) => {
+            if (this.files.get(( from.toString())) === file) {
+                this.files.delete(( from.toString()));
+                this._onDidChangeFile.fire([{
+                        resource: from,
+                        type: 2
+                    }]);
+                this.files.set(( to.toString()), file);
+                this._onDidChangeFile.fire([{
+                        resource: to,
+                        type: 1
+                    }]);
+            }
+        }));
+        return disposableStore;
     }
     async stat(resource) {
-        const resourceUri = ( resource.toString(true));
+        const resourceUri = ( resource.toString());
+        const file = this.files.get(resourceUri);
+        if (file != null) {
+            return file.stats();
+        }
         const handledUris = Array.from(( this.files.keys()));
         for (const handledUri of handledUris) {
-            if (handledUri === resourceUri) {
-                return {
-                    ctime: Date.now(),
-                    mtime: Date.now(),
-                    size: 0,
-                    type: FileType.File,
-                    permissions: FilePermission.Readonly
-                };
-            }
-            else if (handledUri.startsWith(resourceUri + '/')) {
+            if (handledUri.startsWith(resourceUri + '/')) {
                 return {
                     ctime: Date.now(),
                     mtime: Date.now(),
@@ -86,7 +173,7 @@ class StaticFileSystemProvider extends Disposable {
     async readFile(resource) {
         const file = this.files.get(( resource.toString()));
         if (file != null) {
-            const data = await file.getContent();
+            const data = await file.read();
             if (data instanceof Uint8Array) {
                 return data;
             }
@@ -99,16 +186,31 @@ class StaticFileSystemProvider extends Disposable {
     watch() {
         return Disposable.None;
     }
-    async writeFile() {
+    async writeFile(resource, content) {
+        const file = this.files.get(( resource.toString()));
+        if (file?.write != null) {
+            await file.write(decoder.decode(content));
+            return;
+        }
         throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
     }
-    async mkdir() {
-        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
+    async delete(resource) {
+        const file = this.files.get(( resource.toString()));
+        if (file != null) {
+            await file.delete();
+            return;
+        }
+        throw createFileSystemProviderError('File not found', FileSystemProviderErrorCode.FileNotFound);
     }
-    async delete() {
-        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
+    async rename(from, to) {
+        const file = this.files.get(( from.toString()));
+        if (file != null) {
+            await file.rename(to);
+            return;
+        }
+        throw createFileSystemProviderError('File not found', FileSystemProviderErrorCode.FileNotFound);
     }
-    async rename() {
+    async mkdir() {
         throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
     }
 }
@@ -116,12 +218,11 @@ function isFullfiled(result) {
     return result.status === 'fulfilled';
 }
 class OverlayFileSystemProvider {
-    constructor(_default) {
-        this._default = _default;
+    constructor() {
         this.providers = [];
         this.onDidChangeCapabilities = Event.None;
         this._onDidChangeFile = new Emitter();
-        this.onDidChangeFile = Event.any(this._default.onDidChangeFile, this._onDidChangeFile.event);
+        this.onDidChangeFile = this._onDidChangeFile.event;
         this._onDidChangeOverlays = new Emitter();
         this.onDidChangeOverlays = this._onDidChangeOverlays.event;
         this.capabilities = 2  | 1024 ;
@@ -147,7 +248,7 @@ class OverlayFileSystemProvider {
         return disposableStore;
     }
     get delegates() {
-        return [...( this.providers.map(({ provider }) => provider)), this._default];
+        return ( this.providers.map(({ provider }) => provider));
     }
     async readFromDelegates(caller) {
         let firstError;
@@ -157,7 +258,11 @@ class OverlayFileSystemProvider {
             }
             catch (err) {
                 firstError ?? (firstError = err);
-                if (err instanceof FileSystemProviderError && err.code === FileSystemProviderErrorCode.FileNotFound) {
+                if (err instanceof FileSystemProviderError && [
+                    FileSystemProviderErrorCode.NoPermissions,
+                    FileSystemProviderErrorCode.FileNotFound,
+                    FileSystemProviderErrorCode.Unavailable
+                ].includes(err.code)) {
                     continue;
                 }
                 throw err;
@@ -165,12 +270,36 @@ class OverlayFileSystemProvider {
         }
         throw firstError;
     }
-    async writeToDelegates(caller) {
-        const firstWritableProvider = this.delegates.find(provider => ((provider.capabilities & 2048) ) === 0);
-        return caller(firstWritableProvider);
+    async writeToDelegates(resource, caller) {
+        for (const provider of this.delegates) {
+            if (((provider.capabilities & 2048) ) > 0) {
+                continue;
+            }
+            try {
+                return await caller(provider);
+            }
+            catch (err) {
+                if (err instanceof FileSystemProviderError && [
+                    FileSystemProviderErrorCode.NoPermissions,
+                    FileSystemProviderErrorCode.FileNotFound,
+                    FileSystemProviderErrorCode.Unavailable
+                ].includes(err.code)) {
+                    continue;
+                }
+                throw err;
+            }
+        }
+        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
     }
     async stat(resource) {
-        return this.readFromDelegates(delegate => delegate.stat(resource));
+        return this.readFromDelegates(async (delegate) => {
+            const result = await delegate.stat(resource);
+            const readOnly = ((delegate.capabilities & 2048) ) > 0;
+            return {
+                ...result,
+                permissions: result.permissions ?? (readOnly ? FilePermission.Readonly : undefined)
+            };
+        });
     }
     async readFile(resource) {
         return this.readFromDelegates(delegate => delegate.readFile(resource));
@@ -190,16 +319,26 @@ class OverlayFileSystemProvider {
         return store;
     }
     async writeFile(resource, content, opts) {
-        await this.writeToDelegates(delegate => delegate.writeFile(resource, content, opts));
+        await this.writeToDelegates(resource, async (delegate) => {
+            try {
+                const stats = await delegate.stat(resource);
+                if (((stats.permissions ?? 0) & FilePermission.Readonly) > 0) {
+                    throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
+                }
+            }
+            catch (err) {
+            }
+            return delegate.writeFile(resource, content, opts);
+        });
     }
     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 {
@@ -208,8 +347,9 @@ class MkdirpOnWriteInMemoryFileSystemProvider extends InMemoryFileSystemProvider
         return super.writeFile(resource, content, opts);
     }
 }
-const fileSystemProvider = new OverlayFileSystemProvider(new MkdirpOnWriteInMemoryFileSystemProvider());
-const extensionFileSystemProvider = new StaticFileSystemProvider();
+const fileSystemProvider = new OverlayFileSystemProvider();
+fileSystemProvider.register(0, new MkdirpOnWriteInMemoryFileSystemProvider());
+const extensionFileSystemProvider = new RegisteredFileSystemProvider(true);
 let MemoryFileService = class MemoryFileService extends FileService {
     constructor(logService) {
         super(logService);
@@ -233,10 +373,10 @@ function getServiceOverride() {
         [( IFileService.toString())]: new SyncDescriptor(MemoryFileService)
     };
 }
-function registerExtensionFile(extensionLocation, path, getContent) {
-    return extensionFileSystemProvider.registerFile(joinPath(extensionLocation, path), getContent);
+function registerExtensionFile(extensionLocation, filePath, getContent) {
+    return extensionFileSystemProvider.registerFile(new RegisteredReadOnlyFile(joinPath(extensionLocation, filePath), getContent));
 }
 function registerFileSystemOverlay(priority, provider) {
     return fileSystemProvider.register(priority, provider);
 }
-export { FilePermission, FileType, InMemoryFileSystemProvider, StaticFileSystemProvider, getServiceOverride as default, registerExtensionFile, registerFileSystemOverlay };
+export { FilePermission, FileType, InMemoryFileSystemProvider, RegisteredFile, RegisteredFileSystemProvider, RegisteredMemoryFile, RegisteredReadOnlyFile, getServiceOverride as default, registerExtensionFile, registerFileSystemOverlay };

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

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

package/dist/service-override/keybindings.js

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

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

@@ -1,4 +1,4 @@
-import { I as IInstantiationService } from '../instantiation.js';
+import { a as IInstantiationService } from '../instantiation.js';
 import { I as IEditorOverrideServices } from '../standaloneServices.js';
 import 'monaco-editor';
 

package/dist/service-override/languages.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../node_modules/tslib/tslib.es6.js';
-import '../vscode-services/missing-services.js';
+import '../missing-services.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 import { WorkbenchLanguageService } from '../vscode/vs/workbench/services/language/common/languageService.js';
 import { LanguageConfigurationFileHandler } from '../vscode/vs/workbench/contrib/codeEditor/browser/languageConfigurationExtensionPoint.js';

package/dist/service-override/layout.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../node_modules/tslib/tslib.es6.js';
-import '../vscode-services/missing-services.js';
+import '../missing-services.js';
 import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 import { IWorkbenchLayoutService } from '../vscode/vs/workbench/services/layout/browser/layoutService.js';
 import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';

package/dist/service-override/markers.js

@@ -1,4 +1,4 @@
-import '../vscode-services/missing-services.js';
+import '../missing-services.js';
 import '../vscode/vs/workbench/contrib/markers/browser/markers.contribution.js';
 function getServiceOverride() {
     return {};

package/dist/service-override/model.js

@@ -1,4 +1,4 @@
-import '../vscode-services/missing-services.js';
+import '../missing-services.js';
 import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
 import { TextModelResolverService } from '../vscode/vs/workbench/services/textmodelResolver/common/textModelResolverService.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';

package/dist/service-override/notifications.js

@@ -1,4 +1,4 @@
-import '../vscode-services/missing-services.js';
+import '../missing-services.js';
 import { NotificationsToasts } from '../vscode/vs/workbench/browser/parts/notifications/notificationsToasts.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { NotificationService } from '../vscode/vs/workbench/services/notification/common/notificationService.js';

package/dist/service-override/output.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../node_modules/tslib/tslib.es6.js';
-import '../vscode-services/missing-services.js';
+import '../missing-services.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';

package/dist/service-override/preferences.js

@@ -1,4 +1,4 @@
-import '../vscode-services/missing-services.js';
+import '../missing-services.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 import { IPreferencesService } from '../vscode/vs/workbench/services/preferences/common/preferences.js';
 import { PreferencesService } from '../vscode/vs/workbench/services/preferences/browser/preferencesService.js';

package/dist/service-override/quickaccess.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../node_modules/tslib/tslib.es6.js';
-import '../vscode-services/missing-services.js';
+import '../missing-services.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
 import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';

package/dist/service-override/search.js

@@ -1,4 +1,4 @@
-import '../vscode-services/missing-services.js';
+import '../missing-services.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 import { ISearchService } from '../vscode/vs/workbench/services/search/common/search.js';
 import { SearchService } from '../vscode/vs/workbench/services/search/common/searchService.js';

package/dist/service-override/snippets.js

@@ -1,4 +1,4 @@
-import '../vscode-services/missing-services.js';
+import '../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 { ISnippetsService } from '../vscode/vs/workbench/contrib/snippets/browser/snippets.js';

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

@@ -1,8 +1,8 @@
-import { a as IDisposable, E as Event } from '../event.js';
+import { I as IDisposable, E as Event } from '../event.js';
 import { I as IEditorOverrideServices } from '../standaloneServices.js';
 import { O as OperatingSystem, I as IProcessEnvironment } from '../platform.js';
 import { U as URI } from '../uri.js';
-import { a as IWorkspaceFolderData, b as IWorkspaceFolder } from '../workspace.js';
+import { c as IWorkspaceFolderData, I as IWorkspaceFolder } from '../workspace.js';
 import { T as ThemeIcon } from '../themables.js';
 import 'vscode';
 import '../instantiation.js';

package/dist/service-override/terminal.js

@@ -1,4 +1,4 @@
-import '../vscode-services/missing-services.js';
+import '../missing-services.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 import { TerminalExtensions, ITerminalProfileService, ITerminalProfileResolverService } from '../vscode/vs/workbench/contrib/terminal/common/terminal.js';
 import { ITerminalService, ITerminalEditorService, ITerminalGroupService, ITerminalInstanceService } from '../vscode/vs/workbench/contrib/terminal/browser/terminal.js';