@codingame/monaco-vscode-api 1.78.4 → 1.78.5

package/dist/service-override/configuration.js

@@ -0,0 +1,100 @@
+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 { WorkspaceService } from '../vscode/vs/workbench/services/configuration/browser/configurationService.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
+import { TextResourceConfigurationService } from '../vscode/vs/editor/common/services/textResourceConfigurationService.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IUserDataProfilesService } from 'monaco-editor/esm/vs/platform/userDataProfile/common/userDataProfile.js';
+import { IPolicyService } from 'monaco-editor/esm/vs/platform/policy/common/policy.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IUserDataProfileService } from '../vscode/vs/workbench/services/userDataProfile/common/userDataProfile.js';
+import { IRemoteAgentService } from '../vscode/vs/workbench/services/remote/common/remoteAgentService.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { ConfigurationCache } from '../vscode/vs/workbench/services/configuration/common/configurationCache.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { IWorkbenchEnvironmentService } from '../vscode/vs/workbench/services/environment/common/environmentService.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { LabelService } from '../vscode/vs/workbench/services/label/common/labelService.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
+import { IWorkspacesService } from '../vscode/vs/platform/workspaces/common/workspaces.js';
+import { BrowserWorkspacesService } from '../vscode/vs/workbench/services/workspaces/browser/workspacesService.js';
+import { IWorkspaceEditingService } from '../vscode/vs/workbench/services/workspaces/common/workspaceEditing.js';
+import { AbstractWorkspaceEditingService } from '../vscode/vs/workbench/services/workspaces/browser/abstractWorkspaceEditingService.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import '../vscode/vs/workbench/api/common/configurationExtensionPoint.js';
+import getServiceOverride$1 from './files.js';
+import { memoizedConstructor } from '../tools.js';
+import { registerServiceInitializeParticipant } from '../services.js';
+async function updateUserConfiguration(configurationJson) {
+    const userDataProfilesService = StandaloneServices.get(IUserDataProfilesService);
+    await StandaloneServices.get(IFileService).writeFile(userDataProfilesService.defaultProfile.settingsResource, VSBuffer.fromString(configurationJson));
+}
+async function getUserConfiguration() {
+    const userDataProfilesService = StandaloneServices.get(IUserDataProfilesService);
+    return ( (await StandaloneServices.get(IFileService).readFile(userDataProfilesService.defaultProfile.settingsResource)).value.toString());
+}
+function onUserConfigurationChange(callback) {
+    const userDataProfilesService = StandaloneServices.get(IUserDataProfilesService);
+    return StandaloneServices.get(IFileService).onDidFilesChange(e => {
+        if (e.affects(userDataProfilesService.defaultProfile.settingsResource)) {
+            callback();
+        }
+    });
+}
+const configurationRegistry = ( Registry.as(Extensions.Configuration));
+let InjectedConfigurationService = class InjectedConfigurationService extends WorkspaceService {
+    constructor(workbenchEnvironmentService, userDataProfileService, userDataProfilesService, fileService, remoteAgentService, uriIdentityService, logService, policyService) {
+        const configurationCache = new ConfigurationCache([Schemas.file, Schemas.vscodeUserData, Schemas.tmp], workbenchEnvironmentService, fileService);
+        super({ configurationCache }, workbenchEnvironmentService, userDataProfileService, userDataProfilesService, fileService, remoteAgentService, uriIdentityService, logService, policyService);
+    }
+};
+InjectedConfigurationService = __decorate([
+    ( __param(0, IWorkbenchEnvironmentService)),
+    ( __param(1, IUserDataProfileService)),
+    ( __param(2, IUserDataProfilesService)),
+    ( __param(3, IFileService)),
+    ( __param(4, IRemoteAgentService)),
+    ( __param(5, IUriIdentityService)),
+    ( __param(6, ILogService)),
+    ( __param(7, IPolicyService))
+], InjectedConfigurationService);
+class MonacoWorkspaceEditingService extends AbstractWorkspaceEditingService {
+    async enterWorkspace() {
+    }
+}
+let _defaultWorkspaceUri = URI.file('/workspace');
+registerServiceInitializeParticipant(async (accessor) => {
+    const workspaceService = accessor.get(IWorkspaceContextService);
+    workspaceService.acquireInstantiationService(accessor.get(IInstantiationService));
+    try {
+        await accessor.get(IFileService).createFolder(_defaultWorkspaceUri);
+    }
+    catch (err) {
+    }
+    await workspaceService.initialize({
+        id: generateUuid(),
+        uri: _defaultWorkspaceUri
+    });
+});
+const MemoizedInjectedConfigurationService = memoizedConstructor(InjectedConfigurationService);
+function getServiceOverride(defaultWorkspaceUri) {
+    _defaultWorkspaceUri = defaultWorkspaceUri;
+    return {
+        ...getServiceOverride$1(),
+        [( ILabelService.toString())]: new SyncDescriptor(LabelService, undefined, true),
+        [( IConfigurationService.toString())]: new SyncDescriptor(MemoizedInjectedConfigurationService),
+        [( IWorkspaceContextService.toString())]: new SyncDescriptor(MemoizedInjectedConfigurationService),
+        [( ITextResourceConfigurationService.toString())]: new SyncDescriptor(TextResourceConfigurationService),
+        [( IWorkspaceEditingService.toString())]: new SyncDescriptor(MonacoWorkspaceEditingService),
+        [( IWorkspacesService.toString())]: new SyncDescriptor(BrowserWorkspacesService, undefined, true)
+    };
+}
+export { configurationRegistry, getServiceOverride as default, getUserConfiguration, onUserConfigurationChange, updateUserConfiguration };

package/dist/service-override/debug.js

@@ -0,0 +1,23 @@
+import '../vscode-services/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';
+import { LanguageFeaturesService } from '../vscode/vs/editor/common/services/languageFeaturesService.js';
+import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+import { ConfigurationResolverService } from '../vscode/vs/workbench/services/configurationResolver/browser/configurationResolverService.js';
+import { IConfigurationResolverService } from '../vscode/vs/workbench/services/configurationResolver/common/configurationResolver.js';
+import getServiceOverride$1 from './layout.js';
+import '../vscode/vs/workbench/contrib/debug/browser/debug.contribution.js';
+const original = DebugService.prototype['showError'];
+DebugService.prototype['showError'] = function (message, errorActions) {
+    return original.call(this, message, errorActions, false);
+};
+function getServiceOverride() {
+    return {
+        ...getServiceOverride$1(),
+        [( ILanguageFeaturesService.toString())]: new SyncDescriptor(LanguageFeaturesService),
+        [( IDebugService.toString())]: new SyncDescriptor(DebugService),
+        [( IConfigurationResolverService.toString())]: new SyncDescriptor(ConfigurationResolverService)
+    };
+}
+export { getServiceOverride as default };

package/dist/service-override/dialogs.js

@@ -0,0 +1,13 @@
+import '../vscode-services/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 } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import getServiceOverride$1 from './layout.js';
+function getServiceOverride(container) {
+    return {
+        [( IDialogService.toString())]: new SyncDescriptor(DialogService, undefined, true),
+        ...getServiceOverride$1(container)
+    };
+}
+export { getServiceOverride as default };

package/dist/service-override/files.js

@@ -0,0 +1,244 @@
+import { __decorate, __param } from '../node_modules/tslib/tslib.es6.js';
+import '../vscode-services/missing-services.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { FileService } from '../vscode/vs/platform/files/common/fileService.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { InMemoryFileSystemProvider } from '../vscode/vs/platform/files/common/inMemoryFilesystemProvider.js';
+import { createFileSystemProviderError, FileSystemProviderErrorCode, FileType, 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 { ITextFileService } from '../vscode/vs/workbench/services/textfile/common/textfiles.js';
+import { BrowserTextFileService } from '../vscode/vs/workbench/services/textfile/browser/browserTextFileService.js';
+import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import '../vscode/vs/workbench/contrib/files/browser/files.contribution.js';
+class File {
+    constructor(getContent) {
+        this.getContent = getContent;
+        this.ctime = Date.now();
+        this.mtime = Date.now();
+        this.size = 0;
+        this.type = FileType.File;
+    }
+}
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+class SimpleTextFileSystemProvider {
+    constructor() {
+        this.onDidChangeCapabilities = Event.None;
+        this.capabilities = 2  | 1024 ;
+        this.onDidChangeFile = Event.None;
+        this.onDidWatchError = Event.None;
+    }
+    async readFile(resource) {
+        try {
+            const content = await this.getFileContent(resource);
+            if (content != null) {
+                return encoder.encode(content);
+            }
+        }
+        catch (err) {
+            throw createFileSystemProviderError(err, FileSystemProviderErrorCode.Unknown);
+        }
+        throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
+    }
+    async writeFile(resource, content, opts) {
+        try {
+            await this.setFileContent(resource, decoder.decode(content), opts);
+        }
+        catch (err) {
+            throw createFileSystemProviderError(err, FileSystemProviderErrorCode.Unknown);
+        }
+    }
+    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()
+                };
+            }
+        }
+        catch (err) {
+            throw createFileSystemProviderError(err, FileSystemProviderErrorCode.Unknown);
+        }
+        throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
+    }
+    async mkdir() {
+    }
+    readdir() {
+        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
+    }
+    delete() {
+        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
+    }
+    rename() {
+        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
+    }
+}
+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()));
+        if (file != null) {
+            return encoder.encode(await file.getContent());
+        }
+        throw FileSystemProviderError.create('file not found', FileSystemProviderErrorCode.FileNotFound);
+    }
+    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);
+    }
+    async rename() {
+        throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
+    }
+}
+const extensionFileSystemProvider = new ExtensionFileSystemProviderWithFileReadWriteCapability();
+class OverlayFileSystemProvider {
+    constructor(_default) {
+        this._default = _default;
+        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.capabilities = 2  | 1024 ;
+        _default.onDidChangeFile((e) => {
+            this._onDidChangeFile.fire(e);
+        });
+    }
+    register(delegate) {
+        this.others.push(delegate);
+        const disposableStore = new DisposableStore();
+        disposableStore.add(delegate.onDidChangeFile(e => {
+            this._onDidChangeFile.fire(e);
+        }));
+        disposableStore.add({
+            dispose: () => {
+                const index = this.others.indexOf(delegate);
+                if (index >= 0) {
+                    this.others.splice(index, 1);
+                }
+            }
+        });
+        return disposableStore;
+    }
+    get delegates() {
+        return [this._default, ...this.others];
+    }
+    async readFromDelegates(caller) {
+        let firstError;
+        for (const delegate of this.delegates) {
+            try {
+                return await caller(delegate);
+            }
+            catch (err) {
+                firstError ?? (firstError = err);
+                if (err instanceof FileSystemProviderError && err.code === FileSystemProviderErrorCode.FileNotFound) {
+                    continue;
+                }
+                throw err;
+            }
+        }
+        throw firstError;
+    }
+    async writeToDelegates(caller) {
+        await Promise.all(( this.delegates.map(async (delegate) => {
+            if (((delegate.capabilities & 2048) ) === 0) {
+                await caller(delegate);
+            }
+        })));
+    }
+    async stat(resource) {
+        return this.readFromDelegates(delegate => delegate.stat(resource));
+    }
+    async readFile(resource) {
+        return this.readFromDelegates(delegate => delegate.readFile(resource));
+    }
+    async readdir(resource) {
+        return this.readFromDelegates(delegate => delegate.readdir(resource));
+    }
+    watch(resource, opts) {
+        const store = new DisposableStore();
+        for (const delegate of this.delegates) {
+            store.add(delegate.watch(resource, opts));
+        }
+        return store;
+    }
+    async writeFile(resource, content, opts) {
+        await this.writeToDelegates(delegate => delegate.writeFile(resource, content, opts));
+    }
+    async mkdir(resource) {
+        await this.writeToDelegates(delegate => delegate.mkdir(resource));
+    }
+    async delete(resource, opts) {
+        await this.writeToDelegates(delegate => delegate.delete(resource, opts));
+    }
+    async rename(from, to, opts) {
+        await this.writeToDelegates(delegate => delegate.rename(from, to, opts));
+    }
+}
+const fileSystemProvider = new OverlayFileSystemProvider(new InMemoryFileSystemProvider());
+let MemoryFileService = class MemoryFileService extends FileService {
+    constructor(logService) {
+        super(logService);
+        const userMemoryFileSystem = new InMemoryFileSystemProvider();
+        this.registerProvider('user', userMemoryFileSystem);
+        this.registerProvider('extension', extensionFileSystemProvider);
+        this.registerProvider('cache', new InMemoryFileSystemProvider());
+        this.registerProvider('logs', new InMemoryFileSystemProvider());
+        this.registerProvider('file', fileSystemProvider);
+    }
+};
+MemoryFileService = __decorate([
+    ( __param(0, ILogService))
+], MemoryFileService);
+function getServiceOverride() {
+    return {
+        [( IFileService.toString())]: new SyncDescriptor(MemoryFileService),
+        [( ITextFileService.toString())]: new SyncDescriptor(BrowserTextFileService)
+    };
+}
+function registerExtensionFile(extensionLocation, path, getContent) {
+    return extensionFileSystemProvider.registerFile(joinPath(extensionLocation, path), getContent);
+}
+function registerFileSystemOverlay(provider) {
+    return fileSystemProvider.register(provider);
+}
+export { SimpleTextFileSystemProvider, getServiceOverride as default, registerExtensionFile, registerFileSystemOverlay };

package/dist/service-override/keybindings.js

@@ -0,0 +1,100 @@
+import { __decorate, __param } from '../node_modules/tslib/tslib.es6.js';
+import '../vscode-services/missing-services.js';
+import { StandaloneServices, StandaloneKeybindingService } 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';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { KeybindingResolver } from 'monaco-editor/esm/vs/platform/keybinding/common/keybindingResolver.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/quickinput/common/quickAccess.js';
+import { StandaloneCommandsQuickAccessProvider } from 'monaco-editor/esm/vs/editor/standalone/browser/quickAccess/standaloneCommandsQuickAccess.js';
+import { CommandsQuickAccessProvider } from '../vscode/vs/workbench/contrib/quickaccess/browser/commandsQuickAccess.js';
+import { IUserDataProfilesService } from 'monaco-editor/esm/vs/platform/userDataProfile/common/userDataProfile.js';
+import { IKeyboardLayoutService } from '../vscode/vs/platform/keyboardLayout/common/keyboardLayout.js';
+import { BrowserKeyboardLayoutService } from '../vscode/vs/workbench/services/keybinding/browser/keyboardLayoutService.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import getServiceOverride$1 from './files.js';
+import { createInjectedClass } from '../tools/injection.js';
+let DelegateStandaloneKeybindingService = class DelegateStandaloneKeybindingService extends createInjectedClass(StandaloneKeybindingService) {
+    constructor(instantiationService) {
+        super(instantiationService);
+        this.delegate = instantiationService.createInstance(WorkbenchKeybindingService);
+        this._cachedOverridenResolver = null;
+        this.onDidUpdateKeybindings(() => {
+            this._cachedOverridenResolver = null;
+        });
+        this.delegate.onDidUpdateKeybindings(() => {
+            this._cachedOverridenResolver = null;
+        });
+    }
+    _getResolver() {
+        if (this._cachedOverridenResolver == null) {
+            const overrides = this['_toNormalizedKeybindingItems'](this['_dynamicKeybindings'], false);
+            this._cachedOverridenResolver = new KeybindingResolver(
+            [...this.delegate['_getResolver']().getKeybindings()], overrides, (str) => this._log(str));
+        }
+        return this._cachedOverridenResolver;
+    }
+};
+DelegateStandaloneKeybindingService = __decorate([
+    ( __param(0, IInstantiationService))
+], DelegateStandaloneKeybindingService);
+const quickAccessRegistry = ( Registry.as(Extensions.Quickaccess));
+const provider = quickAccessRegistry.getQuickAccessProviders().find(provider => provider.ctor === StandaloneCommandsQuickAccessProvider);
+if (provider != null) {
+    provider.ctor = class extends CommandsQuickAccessProvider {
+        get defaultFilterValue() { return undefined; }
+        async getCommandPicks(token) {
+            return ( (await super.getCommandPicks(token)).map(pick => {
+                pick.buttons = [];
+                return pick;
+            }));
+        }
+    };
+}
+const configurationRegistry = ( Registry.as(Extensions$1.Configuration));
+configurationRegistry.registerConfiguration({
+    properties: {
+        'workbench.commandPalette.history': {
+            type: 'number',
+            description: ( localize(
+                'commandHistory',
+                'Controls the number of recently used commands to keep in history for the command palette. Set to 0 to disable command history.'
+            )),
+            default: 50,
+            minimum: 0
+        },
+        'workbench.commandPalette.preserveInput': {
+            type: 'boolean',
+            description: ( localize(
+                'preserveInput',
+                'Controls whether the last typed input to the command palette should be restored when opening it the next time.'
+            )),
+            default: false
+        },
+        'workbench.commandPalette.experimental.suggestCommands': {
+            type: 'boolean',
+            description: ( localize(
+                'suggestCommands',
+                'Controls whether the command palette should have a list of commonly used commands.'
+            )),
+            default: false
+        }
+    }
+});
+async function updateUserKeybindings(keybindingsJson) {
+    const userDataProfilesService = StandaloneServices.get(IUserDataProfilesService);
+    await StandaloneServices.get(IFileService).writeFile(userDataProfilesService.defaultProfile.keybindingsResource, VSBuffer.fromString(keybindingsJson));
+}
+function getServiceOverride() {
+    return {
+        ...getServiceOverride$1(),
+        [( IKeybindingService.toString())]: new SyncDescriptor(DelegateStandaloneKeybindingService),
+        [( IKeyboardLayoutService.toString())]: new SyncDescriptor(BrowserKeyboardLayoutService, undefined, true)
+    };
+}
+export { getServiceOverride as default, updateUserKeybindings };

package/dist/service-override/languages.js

@@ -0,0 +1,27 @@
+import { __decorate, __param } from '../node_modules/tslib/tslib.es6.js';
+import '../vscode-services/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';
+import { Extensions } from '../vscode/vs/workbench/common/contributions.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import getServiceOverride$1 from './files.js';
+let ExtensionPoints = class ExtensionPoints {
+    constructor(instantiationService) {
+        this.instantiationService = instantiationService;
+        this.instantiationService.createInstance(LanguageConfigurationFileHandler);
+    }
+};
+ExtensionPoints = __decorate([
+    ( __param(0, IInstantiationService))
+], ExtensionPoints);
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(ExtensionPoints, 1 );
+function getServiceOverride() {
+    return {
+        ...getServiceOverride$1(),
+        [( ILanguageService.toString())]: new SyncDescriptor(WorkbenchLanguageService)
+    };
+}
+export { ExtensionPoints, getServiceOverride as default };

package/dist/service-override/layout.js

@@ -0,0 +1,41 @@
+import '../vscode-services/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';
+import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+class LayoutService {
+    constructor(container) {
+        this.container = container;
+        this.onDidChangePartVisibility = Event.None;
+        this.offset = { top: 0, quickPickTop: 0 };
+        this._onDidLayout = new Emitter();
+        this.onDidLayout = this._onDidLayout.event;
+        window.addEventListener('resize', () => this.layout());
+        this.layout();
+    }
+    isVisible() {
+        return false;
+    }
+    get dimension() { return this._dimension; }
+    layout() {
+        this._dimension = dom.getClientArea(window.document.body);
+        this._onDidLayout.fire(this._dimension);
+    }
+    get hasContainer() {
+        return true;
+    }
+    focus() {
+        StandaloneServices.get(ICodeEditorService).getFocusedCodeEditor()?.focus();
+    }
+}
+function getServiceOverride(container = document.body) {
+    container.classList.add('monaco-workbench');
+    return {
+        [( ILayoutService.toString())]: new SyncDescriptor(LayoutService, [container]),
+        [( IWorkbenchLayoutService.toString())]: new SyncDescriptor(LayoutService, [container])
+    };
+}
+export { getServiceOverride as default };