@codingame/monaco-vscode-api 1.76.1 → 1.76.3-next.0

package/dist/extensionResourceLoader.js

@@ -0,0 +1,96 @@
+import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { cq as getRemoteServerRootPath, h as format2, s as supportsTelemetry, cr as getTelemetryLevel } from './missing-services.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { RemoteAuthorities } from 'monaco-editor/esm/vs/base/common/network.js';
+import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+const _UUIDPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isUUID(value) {
+    return _UUIDPattern.test(value);
+}
+async function getServiceMachineId(environmentService, fileService, storageService) {
+    let uuid = storageService ? storageService.get('storage.serviceMachineId', -1 ) || null : null;
+    if (uuid) {
+        return uuid;
+    }
+    try {
+        const contents = await fileService.readFile(environmentService.serviceMachineIdResource);
+        const value = ( contents.value.toString());
+        uuid = isUUID(value) ? value : null;
+    }
+    catch (e) {
+        uuid = null;
+    }
+    if (!uuid) {
+        uuid = generateUuid();
+        try {
+            await fileService.writeFile(environmentService.serviceMachineIdResource, VSBuffer.fromString(uuid));
+        }
+        catch (error) {
+        }
+    }
+    storageService?.store('storage.serviceMachineId', uuid, -1 , 1 );
+    return uuid;
+}
+const WEB_EXTENSION_RESOURCE_END_POINT = 'web-extension-resource';
+const IExtensionResourceLoaderService = ( createDecorator('extensionResourceLoaderService'));
+class AbstractExtensionResourceLoaderService {
+    constructor(_fileService, _storageService, _productService, _environmentService, _configurationService) {
+        this._fileService = _fileService;
+        this._storageService = _storageService;
+        this._productService = _productService;
+        this._environmentService = _environmentService;
+        this._configurationService = _configurationService;
+        this._webExtensionResourceEndPoint = `${getRemoteServerRootPath(_productService)}/${WEB_EXTENSION_RESOURCE_END_POINT}/`;
+        if (_productService.extensionsGallery) {
+            this._extensionGalleryResourceUrlTemplate = _productService.extensionsGallery.resourceUrlTemplate;
+            this._extensionGalleryAuthority = this._extensionGalleryResourceUrlTemplate ? this._getExtensionGalleryAuthority(( URI.parse(this._extensionGalleryResourceUrlTemplate))) : undefined;
+        }
+    }
+    get supportsExtensionGalleryResources() {
+        return this._extensionGalleryResourceUrlTemplate !== undefined;
+    }
+    getExtensionGalleryResourceURL(galleryExtension, path) {
+        if (this._extensionGalleryResourceUrlTemplate) {
+            const uri = ( URI.parse(
+                format2(this._extensionGalleryResourceUrlTemplate, { publisher: galleryExtension.publisher, name: galleryExtension.name, version: galleryExtension.version, path: 'extension' })
+            ));
+            return this._isWebExtensionResourceEndPoint(uri) ? uri.with({ scheme: RemoteAuthorities.getPreferredWebSchema() }) : uri;
+        }
+        return undefined;
+    }
+    isExtensionGalleryResource(uri) {
+        return this._extensionGalleryAuthority && this._extensionGalleryAuthority === this._getExtensionGalleryAuthority(uri);
+    }
+    async getExtensionGalleryRequestHeaders() {
+        const headers = {
+            'X-Client-Name': `${this._productService.applicationName}${isWeb ? '-web' : ''}`,
+            'X-Client-Version': this._productService.version
+        };
+        if (supportsTelemetry(this._productService, this._environmentService) && getTelemetryLevel(this._configurationService) === 3 ) {
+            headers['X-Machine-Id'] = await this._getServiceMachineId();
+        }
+        if (this._productService.commit) {
+            headers['X-Client-Commit'] = this._productService.commit;
+        }
+        return headers;
+    }
+    _getServiceMachineId() {
+        if (!this._serviceMachineIdPromise) {
+            this._serviceMachineIdPromise = getServiceMachineId(this._environmentService, this._fileService, this._storageService);
+        }
+        return this._serviceMachineIdPromise;
+    }
+    _getExtensionGalleryAuthority(uri) {
+        if (this._isWebExtensionResourceEndPoint(uri)) {
+            return uri.authority;
+        }
+        const index = uri.authority.indexOf('.');
+        return index !== -1 ? uri.authority.substring(index + 1) : undefined;
+    }
+    _isWebExtensionResourceEndPoint(uri) {
+        return uri.path.startsWith(this._webExtensionResourceEndPoint);
+    }
+}
+export { AbstractExtensionResourceLoaderService as A, IExtensionResourceLoaderService as I };

package/dist/extensions.d.ts

@@ -0,0 +1,491 @@
+import * as vscode from 'vscode';
+
+/**
+ * Uniform Resource Identifier (URI) http://tools.ietf.org/html/rfc3986.
+ * This class is a simple parser which creates the basic component parts
+ * (http://tools.ietf.org/html/rfc3986#section-3) with minimal validation
+ * and encoding.
+ *
+ * ```txt
+ *       foo://example.com:8042/over/there?name=ferret#nose
+ *       \_/   \______________/\_________/ \_________/ \__/
+ *        |           |            |            |        |
+ *     scheme     authority       path        query   fragment
+ *        |   _____________________|__
+ *       / \ /                        \
+ *       urn:example:animal:ferret:nose
+ * ```
+ */
+declare class URI implements UriComponents {
+    static isUri(thing: any): thing is URI;
+    /**
+     * scheme is the 'http' part of 'http://www.example.com/some/path?query#fragment'.
+     * The part before the first colon.
+     */
+    readonly scheme: string;
+    /**
+     * authority is the 'www.example.com' part of 'http://www.example.com/some/path?query#fragment'.
+     * The part between the first double slashes and the next slash.
+     */
+    readonly authority: string;
+    /**
+     * path is the '/some/path' part of 'http://www.example.com/some/path?query#fragment'.
+     */
+    readonly path: string;
+    /**
+     * query is the 'query' part of 'http://www.example.com/some/path?query#fragment'.
+     */
+    readonly query: string;
+    /**
+     * fragment is the 'fragment' part of 'http://www.example.com/some/path?query#fragment'.
+     */
+    readonly fragment: string;
+    /**
+     * @internal
+     */
+    protected constructor(scheme: string, authority?: string, path?: string, query?: string, fragment?: string, _strict?: boolean);
+    /**
+     * @internal
+     */
+    protected constructor(components: UriComponents);
+    /**
+     * Returns a string representing the corresponding file system path of this URI.
+     * Will handle UNC paths, normalizes windows drive letters to lower-case, and uses the
+     * platform specific path separator.
+     *
+     * * Will *not* validate the path for invalid characters and semantics.
+     * * Will *not* look at the scheme of this URI.
+     * * The result shall *not* be used for display purposes but for accessing a file on disk.
+     *
+     *
+     * The *difference* to `URI#path` is the use of the platform specific separator and the handling
+     * of UNC paths. See the below sample of a file-uri with an authority (UNC path).
+     *
+     * ```ts
+        const u = URI.parse('file://server/c$/folder/file.txt')
+        u.authority === 'server'
+        u.path === '/shares/c$/file.txt'
+        u.fsPath === '\\server\c$\folder\file.txt'
+    ```
+     *
+     * Using `URI#path` to read a file (using fs-apis) would not be enough because parts of the path,
+     * namely the server name, would be missing. Therefore `URI#fsPath` exists - it's sugar to ease working
+     * with URIs that represent files on disk (`file` scheme).
+     */
+    get fsPath(): string;
+    with(change: {
+        scheme?: string;
+        authority?: string | null;
+        path?: string | null;
+        query?: string | null;
+        fragment?: string | null;
+    }): URI;
+    /**
+     * Creates a new URI from a string, e.g. `http://www.example.com/some/path`,
+     * `file:///usr/home`, or `scheme:with/path`.
+     *
+     * @param value A string which represents an URI (see `URI#toString`).
+     */
+    static parse(value: string, _strict?: boolean): URI;
+    /**
+     * Creates a new URI from a file system path, e.g. `c:\my\files`,
+     * `/usr/home`, or `\\server\share\some\path`.
+     *
+     * The *difference* between `URI#parse` and `URI#file` is that the latter treats the argument
+     * as path, not as stringified-uri. E.g. `URI.file(path)` is **not the same as**
+     * `URI.parse('file://' + path)` because the path might contain characters that are
+     * interpreted (# and ?). See the following sample:
+     * ```ts
+    const good = URI.file('/coding/c#/project1');
+    good.scheme === 'file';
+    good.path === '/coding/c#/project1';
+    good.fragment === '';
+    const bad = URI.parse('file://' + '/coding/c#/project1');
+    bad.scheme === 'file';
+    bad.path === '/coding/c'; // path is now broken
+    bad.fragment === '/project1';
+    ```
+     *
+     * @param path A file system path (see `URI#fsPath`)
+     */
+    static file(path: string): URI;
+    static from(components: {
+        scheme: string;
+        authority?: string;
+        path?: string;
+        query?: string;
+        fragment?: string;
+    }): URI;
+    /**
+     * Join a URI path with path fragments and normalizes the resulting path.
+     *
+     * @param uri The input URI.
+     * @param pathFragment The path fragment to add to the URI path.
+     * @returns The resulting URI.
+     */
+    static joinPath(uri: URI, ...pathFragment: string[]): URI;
+    /**
+     * Creates a string representation for this URI. It's guaranteed that calling
+     * `URI.parse` with the result of this function creates an URI which is equal
+     * to this URI.
+     *
+     * * The result shall *not* be used for display purposes but for externalization or transport.
+     * * The result will be encoded using the percentage encoding and encoding happens mostly
+     * ignore the scheme-specific encoding rules.
+     *
+     * @param skipEncoding Do not encode the result, default is `false`
+     */
+    toString(skipEncoding?: boolean): string;
+    toJSON(): UriComponents;
+    static revive(data: UriComponents | URI): URI;
+    static revive(data: UriComponents | URI | undefined): URI | undefined;
+    static revive(data: UriComponents | URI | null): URI | null;
+    static revive(data: UriComponents | URI | undefined | null): URI | undefined | null;
+}
+interface UriComponents {
+    scheme: string;
+    authority: string;
+    path: string;
+    query: string;
+    fragment: string;
+}
+
+interface ILocalizedString {
+    /**
+     * The localized value of the string.
+     */
+    value: string;
+    /**
+     * The original (non localized value of the string)
+     */
+    original: string;
+}
+
+/**
+ * Type of extension.
+ *
+ * **NOTE**: This is defined in `platform/environment` because it can appear as a CLI argument.
+ */
+type ExtensionKind = 'ui' | 'workspace' | 'web';
+
+interface ICommand {
+    command: string;
+    title: string | ILocalizedString;
+    category?: string | ILocalizedString;
+}
+interface IConfigurationProperty {
+    description: string;
+    type: string | string[];
+    default?: any;
+}
+interface IConfiguration {
+    id?: string;
+    order?: number;
+    title?: string;
+    properties: {
+        [key: string]: IConfigurationProperty;
+    };
+}
+interface IDebugger {
+    label?: string;
+    type: string;
+    runtime?: string;
+}
+interface IGrammar {
+    language: string;
+}
+interface IJSONValidation {
+    fileMatch: string | string[];
+    url: string;
+}
+interface IKeyBinding {
+    command: string;
+    key: string;
+    when?: string;
+    mac?: string;
+    linux?: string;
+    win?: string;
+}
+interface ILanguage {
+    id: string;
+    extensions: string[];
+    aliases: string[];
+}
+interface IMenu {
+    command: string;
+    alt?: string;
+    when?: string;
+    group?: string;
+}
+interface ISnippet {
+    language: string;
+}
+interface ITheme {
+    label: string;
+}
+interface IViewContainer {
+    id: string;
+    title: string;
+}
+interface IView {
+    id: string;
+    name: string;
+}
+interface IColor {
+    id: string;
+    description: string;
+    defaults: {
+        light: string;
+        dark: string;
+        highContrast: string;
+    };
+}
+interface IWebviewEditor {
+    readonly viewType: string;
+    readonly priority: string;
+    readonly selector: readonly {
+        readonly filenamePattern?: string;
+    }[];
+}
+interface ICodeActionContributionAction {
+    readonly kind: string;
+    readonly title: string;
+    readonly description?: string;
+}
+interface ICodeActionContribution {
+    readonly languages: readonly string[];
+    readonly actions: readonly ICodeActionContributionAction[];
+}
+interface IAuthenticationContribution {
+    readonly id: string;
+    readonly label: string;
+}
+interface IWalkthroughStep {
+    readonly id: string;
+    readonly title: string;
+    readonly description: string | undefined;
+    readonly media: {
+        image: string | {
+            dark: string;
+            light: string;
+            hc: string;
+        };
+        altText: string;
+        markdown?: never;
+        svg?: never;
+    } | {
+        markdown: string;
+        image?: never;
+        svg?: never;
+    } | {
+        svg: string;
+        altText: string;
+        markdown?: never;
+        image?: never;
+    };
+    readonly completionEvents?: string[];
+    /** @deprecated use `completionEvents: 'onCommand:...'` */
+    readonly doneOn?: {
+        command: string;
+    };
+    readonly when?: string;
+}
+interface IWalkthrough {
+    readonly id: string;
+    readonly title: string;
+    readonly icon?: string;
+    readonly description: string;
+    readonly steps: IWalkthroughStep[];
+    readonly featuredFor: string[] | undefined;
+    readonly when?: string;
+}
+interface IStartEntry {
+    readonly title: string;
+    readonly description: string;
+    readonly command: string;
+    readonly when?: string;
+    readonly category: 'file' | 'folder' | 'notebook';
+}
+interface INotebookEntry {
+    readonly type: string;
+    readonly displayName: string;
+}
+interface INotebookRendererContribution {
+    readonly id: string;
+    readonly displayName: string;
+    readonly mimeTypes: string[];
+}
+interface ITranslation {
+    id: string;
+    path: string;
+}
+interface ILocalizationContribution {
+    languageId: string;
+    languageName?: string;
+    localizedLanguageName?: string;
+    translations: ITranslation[];
+    minimalTranslations?: {
+        [key: string]: string;
+    };
+}
+interface IExtensionContributions {
+    commands?: ICommand[];
+    configuration?: IConfiguration | IConfiguration[];
+    debuggers?: IDebugger[];
+    grammars?: IGrammar[];
+    jsonValidation?: IJSONValidation[];
+    keybindings?: IKeyBinding[];
+    languages?: ILanguage[];
+    menus?: {
+        [context: string]: IMenu[];
+    };
+    snippets?: ISnippet[];
+    themes?: ITheme[];
+    iconThemes?: ITheme[];
+    productIconThemes?: ITheme[];
+    viewsContainers?: {
+        [location: string]: IViewContainer[];
+    };
+    views?: {
+        [location: string]: IView[];
+    };
+    colors?: IColor[];
+    localizations?: ILocalizationContribution[];
+    readonly customEditors?: readonly IWebviewEditor[];
+    readonly codeActions?: readonly ICodeActionContribution[];
+    authentication?: IAuthenticationContribution[];
+    walkthroughs?: IWalkthrough[];
+    startEntries?: IStartEntry[];
+    readonly notebooks?: INotebookEntry[];
+    readonly notebookRenderer?: INotebookRendererContribution[];
+}
+interface IExtensionCapabilities {
+    readonly virtualWorkspaces?: ExtensionVirtualWorkspaceSupport;
+    readonly untrustedWorkspaces?: ExtensionUntrustedWorkspaceSupport;
+}
+type LimitedWorkspaceSupportType = 'limited';
+type ExtensionUntrustedWorkspaceSupport = {
+    supported: true;
+} | {
+    supported: false;
+    description: string;
+} | {
+    supported: LimitedWorkspaceSupportType;
+    description: string;
+    restrictedConfigurations?: string[];
+};
+type ExtensionVirtualWorkspaceSupport = boolean | {
+    supported: true;
+} | {
+    supported: false | LimitedWorkspaceSupportType;
+    description: string;
+};
+interface IRelaxedExtensionManifest {
+    name: string;
+    displayName?: string;
+    publisher: string;
+    version: string;
+    engines: {
+        readonly vscode: string;
+    };
+    description?: string;
+    main?: string;
+    browser?: string;
+    preview?: boolean;
+    l10n?: string;
+    icon?: string;
+    categories?: string[];
+    keywords?: string[];
+    activationEvents?: string[];
+    extensionDependencies?: string[];
+    extensionPack?: string[];
+    extensionKind?: ExtensionKind | ExtensionKind[];
+    contributes?: IExtensionContributions;
+    repository?: {
+        url: string;
+    };
+    bugs?: {
+        url: string;
+    };
+    enabledApiProposals?: readonly string[];
+    api?: string;
+    scripts?: {
+        [key: string]: string;
+    };
+    capabilities?: IExtensionCapabilities;
+}
+type IExtensionManifest = Readonly<IRelaxedExtensionManifest>;
+declare const enum TargetPlatform {
+    WIN32_X64 = "win32-x64",
+    WIN32_IA32 = "win32-ia32",
+    WIN32_ARM64 = "win32-arm64",
+    LINUX_X64 = "linux-x64",
+    LINUX_ARM64 = "linux-arm64",
+    LINUX_ARMHF = "linux-armhf",
+    ALPINE_X64 = "alpine-x64",
+    ALPINE_ARM64 = "alpine-arm64",
+    DARWIN_X64 = "darwin-x64",
+    DARWIN_ARM64 = "darwin-arm64",
+    WEB = "web",
+    UNIVERSAL = "universal",
+    UNKNOWN = "unknown",
+    UNDEFINED = "undefined"
+}
+/**
+ * **!Do not construct directly!**
+ *
+ * **!Only static methods because it gets serialized!**
+ *
+ * This represents the "canonical" version for an extension identifier. Extension ids
+ * have to be case-insensitive (due to the marketplace), but we must ensure case
+ * preservation because the extension API is already public at this time.
+ *
+ * For example, given an extension with the publisher `"Hello"` and the name `"World"`,
+ * its canonical extension identifier is `"Hello.World"`. This extension could be
+ * referenced in some other extension's dependencies using the string `"hello.world"`.
+ *
+ * To make matters more complicated, an extension can optionally have an UUID. When two
+ * extensions have the same UUID, they are considered equal even if their identifier is different.
+ */
+declare class ExtensionIdentifier {
+    readonly value: string;
+    private readonly _lower;
+    constructor(value: string);
+    static equals(a: ExtensionIdentifier | string | null | undefined, b: ExtensionIdentifier | string | null | undefined): boolean;
+    /**
+     * Gives the value by which to index (for equality).
+     */
+    static toKey(id: ExtensionIdentifier | string): string;
+}
+interface IRelaxedExtensionDescription extends IRelaxedExtensionManifest {
+    id?: string;
+    identifier: ExtensionIdentifier;
+    uuid?: string;
+    targetPlatform: TargetPlatform;
+    isBuiltin: boolean;
+    isUserBuiltin: boolean;
+    isUnderDevelopment: boolean;
+    extensionLocation: URI;
+    browserNlsBundleUris?: {
+        [language: string]: URI;
+    };
+}
+type IExtensionDescription = Readonly<IRelaxedExtensionDescription>;
+
+declare class Disposable {
+    #private;
+    static from(...inDisposables: {
+        dispose(): any;
+    }[]): Disposable;
+    constructor(callOnDispose: () => any);
+    dispose(): any;
+}
+
+declare function createApi(extension: IExtensionDescription): typeof vscode;
+interface RegisterExtensionResult {
+    api: typeof vscode;
+    registerFile: (path: string, getContent: () => Promise<string>) => Disposable;
+}
+declare function registerExtension(manifest: IExtensionManifest): RegisterExtensionResult;
+
+export { IExtensionManifest, createApi, registerExtension };

package/dist/extensions.js

@@ -0,0 +1,70 @@
+import { E as ExtensionsRegistry, a as ExtensionMessageCollector } from './extensionsRegistry.js';
+import { t as toExtensionDescription, g as getExtensionId } from './missing-services.js';
+import { bM as api$1, bN as create, bO as create$1, bP as create$2, bQ as create$5, bR as create$3, bS as create$4, bT as create$6, bU as IExtHostExtensionService } from './api2.js';
+import { c as consoleExtensionMessageHandler } from './polyfill.js';
+import { r as registerExtensionFile } from './files.js';
+import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
+function createApi(extension) {
+    const workspace = create$4(() => extension);
+    return {
+        ...api$1,
+        extensions: create(() => extension),
+        debug: create$1(() => extension),
+        env: create$2(() => extension),
+        commands: create$5(() => extension),
+        window: create$3(() => extension, workspace),
+        workspace: create$4(() => extension),
+        languages: create$6(() => extension)
+    };
+}
+const hasOwnProperty = Object.hasOwnProperty;
+function handleExtensionPoint(extensionPoint, availableExtensions, messageHandler) {
+    const users = [];
+    for (const desc of availableExtensions) {
+        if ((desc.contributes != null) && hasOwnProperty.call(desc.contributes, extensionPoint.name)) {
+            users.push({
+                description: desc,
+                value: desc.contributes[extensionPoint.name],
+                collector: new ExtensionMessageCollector(messageHandler, desc, extensionPoint.name)
+            });
+        }
+    }
+    extensionPoint.acceptUsers(users);
+}
+function registerExtension(manifest) {
+    const uuid = generateUuid();
+    const location = ( URI.from({ scheme: 'extension', path: `/${uuid}` }));
+    const extension = {
+        manifest,
+        type: 1 ,
+        isBuiltin: false,
+        identifier: {
+            id: getExtensionId(manifest.publisher, manifest.name),
+            uuid
+        },
+        location,
+        targetPlatform: "web" ,
+        isValid: true,
+        validations: []
+    };
+    const extensionDescription = toExtensionDescription(extension);
+    void StandaloneServices.get(IExtHostExtensionService).getExtensionRegistry().then(extensionRegistry => {
+        extensionRegistry.deltaExtensions([extensionDescription], []);
+        const availableExtensions = extensionRegistry.getAllExtensionDescriptions();
+        const extensionPoints = ExtensionsRegistry.getExtensionPoints();
+        for (const extensionPoint of extensionPoints) {
+            if (Object.hasOwnProperty.call(extensionDescription.contributes, extensionPoint.name)) {
+                handleExtensionPoint(extensionPoint, availableExtensions, consoleExtensionMessageHandler);
+            }
+        }
+    });
+    return {
+        api: createApi(extensionDescription),
+        registerFile: (path, getContent) => {
+            return registerExtensionFile(location, path, getContent);
+        }
+    };
+}
+export { createApi, registerExtension };

package/dist/{tools.js → extensionsRegistry.js}

@@ -1,12 +1,10 @@
-import { R as productSchemaId } from './services2.js';
+import { aT as productSchemaId } from './services2.js';
 import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { Extensions } from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
 import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
 import { ExtensionIdentifier } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
-import { E as Emitter } from './contextkey.js';
-import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 const EXTENSION_CATEGORIES = [
     'Azure',
     'Data Science',
@@ -897,30 +895,4 @@ schemaRegistry.registerSchema(productSchemaId, {
         }
     }
 });
-function consoleExtensionMessageHandler(msg) {
-    if (msg.type === Severity.Error) {
-        console.error(msg);
-    }
-    else if (msg.type === Severity.Warning) {
-        console.warn(msg);
-    }
-    else {
-        console.log(msg);
-    }
-}
-function getExtensionPoint(extensionPoint) {
-    return ExtensionsRegistry.getExtensionPoints().find(ep => ep.name === extensionPoint);
-}
-const emitter = new Emitter();
-const onServicesInitialized = emitter.event;
-let initialized = false;
-const original = StandaloneServices.initialize;
-StandaloneServices.initialize = (overrides) => {
-    const instantiationService = original.call(StandaloneServices, overrides);
-    if (!initialized) {
-        initialized = true;
-        emitter.fire(instantiationService);
-    }
-    return instantiationService;
-};
-export { ExtensionsRegistry as E, ExtensionMessageCollector as a, consoleExtensionMessageHandler as c, getExtensionPoint as g, onServicesInitialized as o };
+export { ExtensionsRegistry as E, ExtensionMessageCollector as a };