@codingame/monaco-vscode-api 1.78.4 → 1.78.5

package/dist/service-override/modelEditor.js

@@ -0,0 +1,128 @@
+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 { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { TextModelResolverService } from '../vscode/vs/workbench/services/textmodelResolver/common/textModelResolverService.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { CodeEditorService } from '../vscode/vs/workbench/services/editor/browser/codeEditorService.js';
+import { IEditorService, isPreferredGroup, SIDE_GROUP } from '../vscode/vs/workbench/services/editor/common/editorService.js';
+import { isResourceEditorInput, isEditorInput } from '../vscode/vs/workbench/common/editor.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { DEFAULT_EDITOR_MIN_DIMENSIONS, DEFAULT_EDITOR_MAX_DIMENSIONS } from '../vscode/vs/workbench/browser/parts/editor/editor.js';
+import { applyTextEditorOptions } from '../vscode/vs/workbench/common/editor/editorOptions.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ITextEditorService, TextEditorService } from '../vscode/vs/workbench/services/textfile/common/textEditorService.js';
+import '../vscode/vs/workbench/browser/parts/editor/editor.contribution.js';
+import { unsupported } from '../tools.js';
+class SimpleEditorPane {
+    constructor(editor) {
+        this.editor = editor;
+        this.onDidChangeControl = Event.None;
+        this.onDidChangeSizeConstraints = Event.None;
+        this.onDidFocus = Event.None;
+        this.onDidBlur = Event.None;
+        this.input = undefined;
+        this.options = undefined;
+        this.group = undefined;
+        this.scopedContextKeyService = undefined;
+        this.getViewState = unsupported;
+        this.isVisible = unsupported;
+        this.hasFocus = unsupported;
+        this.getId = unsupported;
+        this.getTitle = unsupported;
+        this.focus = unsupported;
+    }
+    get minimumWidth() { return DEFAULT_EDITOR_MIN_DIMENSIONS.width; }
+    get maximumWidth() { return DEFAULT_EDITOR_MAX_DIMENSIONS.width; }
+    get minimumHeight() { return DEFAULT_EDITOR_MIN_DIMENSIONS.height; }
+    get maximumHeight() { return DEFAULT_EDITOR_MAX_DIMENSIONS.height; }
+    getControl() {
+        return this.editor;
+    }
+}
+let EditorService = class EditorService extends Disposable {
+    constructor(_openEditor, textModelService) {
+        super();
+        this._openEditor = _openEditor;
+        this.textModelService = textModelService;
+        this._onDidActiveEditorChange = this._register(new Emitter());
+        this.onDidActiveEditorChange = this._onDidActiveEditorChange.event;
+        this.onDidVisibleEditorsChange = Event.None;
+        this.onDidEditorsChange = Event.None;
+        this.onDidCloseEditor = Event.None;
+        this.activeTextEditorLanguageId = undefined;
+        this.visibleEditorPanes = [];
+        this.visibleEditors = [];
+        this.visibleTextEditorControls = [];
+        this.editors = [];
+        this.count = 0;
+        this.getEditors = () => [];
+        this.openEditors = unsupported;
+        this.replaceEditors = unsupported;
+        this.isOpened = () => false;
+        this.isVisible = () => false;
+        this.findEditors = () => [];
+        this.save = async () => true;
+        this.saveAll = async () => true;
+        this.revert = unsupported;
+        this.revertAll = unsupported;
+        this.closeEditor = unsupported;
+        this.closeEditors = unsupported;
+        setTimeout(() => {
+            const codeEditorService = StandaloneServices.get(ICodeEditorService);
+            this.activeTextEditorControl = codeEditorService.getFocusedCodeEditor() ?? undefined;
+            const handleCodeEditor = (editor) => {
+                const onEditorFocused = () => {
+                    const newFocusedEditor = codeEditorService.getFocusedCodeEditor();
+                    if (newFocusedEditor !== this.activeTextEditorControl) {
+                        this.activeTextEditorControl = newFocusedEditor ?? undefined;
+                        this._onDidActiveEditorChange.fire();
+                    }
+                };
+                editor.onDidFocusEditorText(onEditorFocused);
+                editor.onDidFocusEditorWidget(onEditorFocused);
+            };
+            this._register(codeEditorService.onCodeEditorAdd(handleCodeEditor));
+            codeEditorService.listCodeEditors().forEach(handleCodeEditor);
+        });
+    }
+    async openEditor(editor, optionsOrPreferredGroup, preferredGroup) {
+        const options = isEditorInput(editor) ? optionsOrPreferredGroup : editor.options;
+        if (isPreferredGroup(optionsOrPreferredGroup)) {
+            preferredGroup = optionsOrPreferredGroup;
+        }
+        const resource = isResourceEditorInput(editor) || isEditorInput(editor) ? editor.resource : undefined;
+        if (resource == null) {
+            throw new Error('Diff editors not supported');
+        }
+        let modelEditor;
+        const modelRef = await this.textModelService.createModelReference(resource);
+        const codeEditors = StandaloneServices.get(ICodeEditorService).listCodeEditors();
+        modelEditor = codeEditors.find(editor => editor.getModel() === modelRef.object.textEditorModel);
+        if (modelEditor == null) {
+            modelEditor = await this._openEditor(modelRef, options, preferredGroup === SIDE_GROUP);
+        }
+        if (modelEditor == null) {
+            modelRef.dispose();
+            return undefined;
+        }
+        if (options != null) {
+            applyTextEditorOptions(options, modelEditor, 1 );
+        }
+        modelEditor.focus();
+        return new SimpleEditorPane(modelEditor);
+    }
+};
+EditorService = __decorate([
+    ( __param(1, ITextModelService))
+], EditorService);
+function getServiceOverride(openEditor) {
+    return {
+        [( ITextModelService.toString())]: new SyncDescriptor(TextModelResolverService, undefined, true),
+        [( ICodeEditorService.toString())]: new SyncDescriptor(CodeEditorService, undefined, true),
+        [( IEditorService.toString())]: new SyncDescriptor(EditorService, [openEditor]),
+        [( ITextEditorService.toString())]: new SyncDescriptor(TextEditorService)
+    };
+}
+export { getServiceOverride as default };

package/dist/service-override/notifications.js

@@ -0,0 +1,34 @@
+import '../vscode-services/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';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { registerNotificationCommands } from '../vscode/vs/workbench/browser/parts/notifications/notificationsCommands.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { NotificationsCenter } from '../vscode/vs/workbench/browser/parts/notifications/notificationsCenter.js';
+import { NotificationsAlerts } from '../vscode/vs/workbench/browser/parts/notifications/notificationsAlerts.js';
+import { NotificationsTelemetry } from '../vscode/vs/workbench/browser/parts/notifications/notificationsTelemetry.js';
+import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
+import getServiceOverride$1 from './layout.js';
+import { onRenderWorkbench } from '../services.js';
+onRenderWorkbench(async (accessor) => {
+    const container = accessor.get(ILayoutService).container;
+    const model = accessor.get(INotificationService).model;
+    const instantiationService = accessor.get(IInstantiationService);
+    setTimeout(() => {
+        const notificationsCenter = instantiationService.createInstance(NotificationsCenter, container, model);
+        const notificationsToasts = instantiationService.createInstance(NotificationsToasts, container, model);
+        instantiationService.createInstance(NotificationsAlerts, model);
+        instantiationService.createInstance(NotificationsTelemetry);
+        registerNotificationCommands(notificationsCenter, notificationsToasts, model);
+        notificationsToasts.layout(dom.getClientArea(container));
+    });
+});
+function getServiceOverride(container) {
+    return {
+        [( INotificationService.toString())]: new SyncDescriptor(NotificationService, undefined, true),
+        ...getServiceOverride$1(container)
+    };
+}
+export { getServiceOverride as default };

package/dist/service-override/preferences.js

@@ -0,0 +1,10 @@
+import '../vscode-services/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';
+function getServiceOverride() {
+    return {
+        [( IPreferencesService.toString())]: new SyncDescriptor(PreferencesService)
+    };
+}
+export { getServiceOverride as default };

package/dist/{snippets.js → service-override/snippets.js}

@@ -1,7 +1,9 @@
-import { ISnippetsService, registerServiceInitializeParticipant } from './polyfill.js';
-import { SnippetsService } from './snippetsService.js';
-import getServiceOverride$1 from './files.js';
+import '../vscode-services/missing-services.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { ISnippetsService } from '../vscode/vs/workbench/contrib/snippets/browser/snippets.js';
+import { SnippetsService } from '../vscode/vs/workbench/contrib/snippets/browser/snippetsService.js';
+import getServiceOverride$1 from './files.js';
+import { registerServiceInitializeParticipant } from '../services.js';
 registerServiceInitializeParticipant(async (accessor) => {
     accessor.get(ISnippetsService);
 });

package/dist/service-override/textmate.js

@@ -0,0 +1,36 @@
+import { __decorate, __param } from '../node_modules/tslib/tslib.es6.js';
+import '../vscode-services/missing-services.js';
+import { ITextMateTokenizationService } from '../vscode/vs/workbench/services/textMate/browser/textMateTokenizationFeature.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { TextMateTokenizationFeature } from '../vscode/vs/workbench/services/textMate/browser/textMateTokenizationFeatureImpl.js';
+import { TokenClassificationExtensionPoints } from '../vscode/vs/workbench/services/themes/common/tokenClassificationExtensionPoint.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 _onigWasm from 'vscode-oniguruma/release/onig.wasm';
+import getServiceOverride$1 from './files.js';
+import { registerServiceInitializeParticipant } from '../services.js';
+import { registerAssets } from '../assets.js';
+registerAssets({
+    'vscode-oniguruma/../onig.wasm': _onigWasm
+});
+registerServiceInitializeParticipant(async (accessor) => {
+    accessor.get(ITextMateTokenizationService);
+});
+let ExtensionPoints = class ExtensionPoints {
+    constructor(instantiationService) {
+        this.instantiationService = instantiationService;
+        this.instantiationService.createInstance(TokenClassificationExtensionPoints);
+    }
+};
+ExtensionPoints = __decorate([
+    ( __param(0, IInstantiationService))
+], ExtensionPoints);
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(ExtensionPoints, 1 );
+function getServiceOverride() {
+    return {
+        ...getServiceOverride$1(),
+        [( ITextMateTokenizationService.toString())]: new SyncDescriptor(TextMateTokenizationFeature)
+    };
+}
+export { ITextMateTokenizationService, getServiceOverride as default };

package/dist/service-override/theme.js

@@ -0,0 +1,26 @@
+import '../vscode-services/missing-services.js';
+import { WorkbenchThemeService } from '../vscode/vs/workbench/services/themes/browser/workbenchThemeService.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import getServiceOverride$1 from './files.js';
+class StandaloneWorkbenchThemeService extends WorkbenchThemeService {
+    registerEditorContainer() {
+        return {
+            dispose() { }
+        };
+    }
+    setTheme(themeName) {
+        void this.getColorThemes().then(themes => {
+            setTimeout(() => {
+                void this.setColorTheme(themes.find(theme => theme.settingsId === themeName) ?? themeName, 8 );
+            });
+        });
+    }
+}
+function getServiceOverride() {
+    return {
+        ...getServiceOverride$1(),
+        [( IThemeService.toString())]: new SyncDescriptor(StandaloneWorkbenchThemeService)
+    };
+}
+export { getServiceOverride as default };

package/dist/services.d.ts

@@ -8733,6 +8733,123 @@ declare const ILogService: ServiceIdentifier<ILogService>;
 interface ILogService extends ILogger {
     readonly _serviceBrand: undefined;
 }
+interface ILoggerOptions {
+    /**
+     * Id of the logger.
+     */
+    id?: string;
+    /**
+     * Name of the logger.
+     */
+    name?: string;
+    /**
+     * Do not create rotating files if max size exceeds.
+     */
+    donotRotate?: boolean;
+    /**
+     * Do not use formatters.
+     */
+    donotUseFormatters?: boolean;
+    /**
+     * When to log. Set to `always` to log always.
+     */
+    logLevel?: 'always' | LogLevel;
+    /**
+     * Whether the log should be hidden from the user.
+     */
+    hidden?: boolean;
+    /**
+     * Condition which must be true to show this logger
+     */
+    when?: string;
+    /**
+     * Id of the extension that created this logger.
+     */
+    extensionId?: string;
+}
+interface ILoggerResource {
+    readonly resource: URI;
+    readonly id: string;
+    readonly name?: string;
+    readonly logLevel?: LogLevel;
+    readonly hidden?: boolean;
+    readonly when?: string;
+    readonly extensionId?: string;
+}
+type DidChangeLoggersEvent = {
+    readonly added: Iterable<ILoggerResource>;
+    readonly removed: Iterable<ILoggerResource>;
+};
+declare const ILoggerService: ServiceIdentifier<ILoggerService>;
+interface ILoggerService {
+    readonly _serviceBrand: undefined;
+    /**
+     * Creates a logger for the given resource, or gets one if it already exists.
+     *
+     * This will also register the logger with the logger service.
+     */
+    createLogger(resource: URI, options?: ILoggerOptions): ILogger;
+    /**
+     * Creates a logger with the given id in the logs folder, or gets one if it already exists.
+     *
+     * This will also register the logger with the logger service.
+     */
+    createLogger(id: string, options?: Omit<ILoggerOptions, 'id'>): ILogger;
+    /**
+     * Gets an existing logger, if any.
+     */
+    getLogger(resourceOrId: URI | string): ILogger | undefined;
+    /**
+     * An event which fires when the log level of a logger has changed
+     */
+    readonly onDidChangeLogLevel: Event$1<LogLevel | [URI, LogLevel]>;
+    /**
+     * Set default log level.
+     */
+    setLogLevel(level: LogLevel): void;
+    /**
+     * Set log level for a logger.
+     */
+    setLogLevel(resource: URI, level: LogLevel): void;
+    /**
+     * Get log level for a logger or the default log level.
+     */
+    getLogLevel(resource?: URI): LogLevel;
+    /**
+     * An event which fires when the visibility of a logger has changed
+     */
+    readonly onDidChangeVisibility: Event$1<[URI, boolean]>;
+    /**
+     * Set the visibility of a logger.
+     */
+    setVisibility(resourceOrId: URI | string, visible: boolean): void;
+    /**
+     * An event which fires when the logger resources are changed
+     */
+    readonly onDidChangeLoggers: Event$1<DidChangeLoggersEvent>;
+    /**
+     * Register a logger with the logger service.
+     *
+     * Note that this will not create a logger, but only register it.
+     *
+     * Use `createLogger` to create a logger and register it.
+     *
+     * Use it when you want to register a logger that is not created by the logger service.
+     */
+    registerLogger(resource: ILoggerResource): void;
+    /**
+     * Deregister the logger for the given resource.
+     */
+    deregisterLogger(resource: URI): void;
+    /**
+     * Get all registered loggers
+     */
+    getRegisteredLoggers(): Iterable<ILoggerResource>;
+    /**
+     * Get the registered logger for the given resource.
+     */
+    getRegisteredLogger(resource: URI): ILoggerResource | undefined;
+}
 
 interface IExtUri {
     /**
@@ -17566,4 +17683,4 @@ declare function registerServiceInitializeParticipant(participant: ServiceInitia
 declare const onRenderWorkbench: Event$1<ServicesAccessor>;
 declare function initialize(overrides: IEditorOverrideServices): Promise<void>;
 
-export { ContextKeyExprType, DialogType, IAction, IAudioCueService, IBaseDialogOptions, IBulkEditService, ICheckbox, ICheckboxResult, IClipboardService, ICodeEditorService, IColorTheme, ICommandService, IConfigurationChangeEvent, IConfigurationService, IConfirmDialogArgs, IConfirmation, IConfirmationResult, ICustomDialogMarkdown, ICustomDialogOptions, IDebugService, IDialogArgs, IDialogHandler, IDialogResult, IDialogService, IEditorGroupsService, IEditorService, IEditorWorkerService, IFileService, IHostService, IInput, IInputDialogArgs, IInputElement, IInputResult, IInstantiationService, ILanguageConfigurationService, ILanguageFeaturesService, ILanguageService, ILanguageStatusService, IMarkdownString, IMarkerService, IModelService, INeverShowAgainOptions, INotification, INotificationActions, INotificationHandle, INotificationProgress, INotificationProgressProperties, INotificationProperties, INotificationService, IOpenerService, IPaneCompositePartService, IPathService, IProductService, IPrompt, IPromptBaseButton, IPromptButton, IPromptCancelButton, IPromptChoice, IPromptChoiceWithMenu, IPromptDialogArgs, IPromptOptions, IPromptResult, IPromptResultWithCancel, IPromptWithCustomCancel, IPromptWithDefaultCancel, IQuickInputService, ISnippetsService, IStatusMessageOptions, IStorageService, ITelemetryService, ITextFileService, ITextModelContentProvider, ITextModelService, IThemeService, IUriIdentityService, IWorkbenchEnvironmentService, IWorkingCopyFileService, IWorkspaceContextService, MarkdownStringTrustedOptions, NeverShowAgainScope, NoOpNotification, NoOpProgress, NotificationMessage, NotificationPriority, NotificationsFilter, Severity$1 as Severity, StandaloneServices, StorageScope, StorageTarget, initialize, onRenderWorkbench, registerServiceInitializeParticipant };
+export { ContextKeyExprType, DialogType, IAction, IAudioCueService, IBaseDialogOptions, IBulkEditService, ICheckbox, ICheckboxResult, IClipboardService, ICodeEditorService, IColorTheme, ICommandService, IConfigurationChangeEvent, IConfigurationService, IConfirmDialogArgs, IConfirmation, IConfirmationResult, ICustomDialogMarkdown, ICustomDialogOptions, IDebugService, IDialogArgs, IDialogHandler, IDialogResult, IDialogService, IEditorGroupsService, IEditorService, IEditorWorkerService, IFileService, IHostService, IInput, IInputDialogArgs, IInputElement, IInputResult, IInstantiationService, ILanguageConfigurationService, ILanguageFeaturesService, ILanguageService, ILanguageStatusService, ILogService, ILoggerService, IMarkdownString, IMarkerService, IModelService, INeverShowAgainOptions, INotification, INotificationActions, INotificationHandle, INotificationProgress, INotificationProgressProperties, INotificationProperties, INotificationService, IOpenerService, IPaneCompositePartService, IPathService, IProductService, IPrompt, IPromptBaseButton, IPromptButton, IPromptCancelButton, IPromptChoice, IPromptChoiceWithMenu, IPromptDialogArgs, IPromptOptions, IPromptResult, IPromptResultWithCancel, IPromptWithCustomCancel, IPromptWithDefaultCancel, IQuickInputService, ISnippetsService, IStatusMessageOptions, IStorageService, ITelemetryService, ITextFileService, ITextModelContentProvider, ITextModelService, IThemeService, IUriIdentityService, IWorkbenchEnvironmentService, IWorkingCopyFileService, IWorkspaceContextService, LogLevel, MarkdownStringTrustedOptions, NeverShowAgainScope, NoOpNotification, NoOpProgress, NotificationMessage, NotificationPriority, NotificationsFilter, Severity$1 as Severity, StandaloneServices, StorageScope, StorageTarget, initialize, onRenderWorkbench, registerServiceInitializeParticipant };

package/dist/services.js

@@ -1,7 +1,15 @@
-export { ContextKeyExprType, IDebugService, IEditorGroupsService, IEditorService, IFileService, IHostService, ILanguageStatusService, IPaneCompositePartService, IPathService, IProductService, ISnippetsService, ITextFileService, IUriIdentityService, IWorkbenchEnvironmentService, IWorkingCopyFileService, NeverShowAgainScope, NoOpProgress, NotificationPriority, NotificationsFilter, StorageScope, StorageTarget, initialize, onRenderWorkbench, registerServiceInitializeParticipant } from './polyfill.js';
+import './vscode-services/extHost.js';
+export { default as Severity } from 'monaco-editor/esm/vs/base/common/severity.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from './vscode/vs/workbench/common/contributions.js';
+import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 export { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
+import { ILifecycleService } from './vscode/vs/workbench/services/lifecycle/common/lifecycle.js';
+import { RunOnceScheduler, runWhenIdle } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import getServiceOverride from './service-override/layout.js';
 export { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-export { INotificationService, NoOpNotification } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+export { INotificationService, NeverShowAgainScope, NoOpNotification, NoOpProgress, NotificationPriority, NotificationsFilter } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
 export { IBulkEditService } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
 export { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
 export { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
@@ -12,14 +20,62 @@ export { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model
 export { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
 export { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
 export { IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+export { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 export { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 export { IMarkerService } from 'monaco-editor/esm/vs/platform/markers/common/markers.js';
 export { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+export { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
 export { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
 export { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+export { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+export { IEditorGroupsService } from './vscode/vs/workbench/services/editor/common/editorGroupsService.js';
+export { IEditorService } from './vscode/vs/workbench/services/editor/common/editorService.js';
+export { IWorkbenchEnvironmentService } from './vscode/vs/workbench/services/environment/common/environmentService.js';
+export { IHostService } from './vscode/vs/workbench/services/host/browser/host.js';
+export { ILanguageStatusService } from './vscode/vs/workbench/services/languageStatus/common/languageStatusService.js';
+export { IPaneCompositePartService } from './vscode/vs/workbench/services/panecomposite/browser/panecomposite.js';
+export { IPathService } from './vscode/vs/workbench/services/path/common/pathService.js';
+export { ITextFileService } from './vscode/vs/workbench/services/textfile/common/textfiles.js';
+export { IWorkingCopyFileService } from './vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.js';
 export { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 export { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+export { ISnippetsService } from './vscode/vs/workbench/contrib/snippets/browser/snippets.js';
 export { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
 export { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
 export { IAudioCueService } from 'monaco-editor/esm/vs/platform/audioCues/browser/audioCueService.js';
-export { default as Severity } from 'monaco-editor/esm/vs/base/common/severity.js';
+export { IDebugService } from './vscode/vs/workbench/contrib/debug/common/debug.js';
+export { ILogService, ILoggerService, LogLevel } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+const serviceInitializeParticipants = [];
+function registerServiceInitializeParticipant(participant) {
+    serviceInitializeParticipants.push(participant);
+}
+async function initServices(overrides) {
+    const instantiationService = StandaloneServices.initialize({
+        ...getServiceOverride(),
+        ...overrides
+    });
+    await instantiationService.invokeFunction(async (accessor) => {
+        const lifecycleService = accessor.get(ILifecycleService);
+        await Promise.all(( serviceInitializeParticipants.map(participant => participant(accessor))));
+        lifecycleService.phase = 2 ;
+    });
+    return instantiationService;
+}
+const renderWorkbenchEmitter = new Emitter();
+const onRenderWorkbench = renderWorkbenchEmitter.event;
+async function initialize(overrides) {
+    const instantiationService = await initServices(overrides);
+    instantiationService.invokeFunction(accessor => {
+        const lifecycleService = accessor.get(ILifecycleService);
+        ( Registry.as(Extensions.Workbench)).start(accessor);
+        renderWorkbenchEmitter.fire(accessor);
+        lifecycleService.phase = 3 ;
+        const eventuallyPhaseScheduler = new RunOnceScheduler(() => {
+            runWhenIdle(() => {
+                lifecycleService.phase = 4 ;
+            }, 2500);
+        }, 2500);
+        eventuallyPhaseScheduler.schedule();
+    });
+}
+export { initialize, onRenderWorkbench, registerServiceInitializeParticipant };

package/dist/tools.js

@@ -0,0 +1,20 @@
+function unsupported() {
+    throw new Error('unsupported');
+}
+function memoized(fct) {
+    let v = null;
+    return (...args) => {
+        if (v == null) {
+            v = fct(...args);
+        }
+        return v;
+    };
+}
+function memoizedConstructor(ctor) {
+    return new Proxy(ctor, {
+        construct: memoized((target, args) => {
+            return Reflect.construct(ctor, args);
+        })
+    });
+}
+export { memoized, memoizedConstructor, unsupported };