@codingame/monaco-vscode-notebook-service-override 3.2.3 → 4.1.0

package/vscode/src/vs/workbench/contrib/notebook/browser/services/notebookKernelServiceImpl.js

@@ -1,341 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import { Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { LRUCache, ResourceMap } from 'vscode/vscode/vs/base/common/map';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
-import { MenuId, IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { runWhenWindowIdle, getActiveWindow } from 'vscode/vscode/vs/base/browser/dom';
-
-var NotebookKernelService_1;
-class KernelInfo {
-    static { this._logicClock = 0; }
-    constructor(kernel) {
-        this.notebookPriorities = ( new ResourceMap());
-        this.kernel = kernel;
-        this.score = -1;
-        this.time = KernelInfo._logicClock++;
-    }
-}
-class NotebookTextModelLikeId {
-    static str(k) {
-        return `${k.viewType}/${( k.uri.toString())}`;
-    }
-    static obj(s) {
-        const idx = s.indexOf('/');
-        return {
-            viewType: s.substring(0, idx),
-            uri: ( URI.parse(s.substring(idx + 1)))
-        };
-    }
-}
-class SourceAction extends Disposable {
-    constructor(action, model, isPrimary) {
-        super();
-        this.action = action;
-        this.model = model;
-        this.isPrimary = isPrimary;
-        this._onDidChangeState = this._register(( new Emitter()));
-        this.onDidChangeState = this._onDidChangeState.event;
-    }
-    async runAction() {
-        if (this.execution) {
-            return this.execution;
-        }
-        this.execution = this._runAction();
-        this._onDidChangeState.fire();
-        await this.execution;
-        this.execution = undefined;
-        this._onDidChangeState.fire();
-    }
-    async _runAction() {
-        try {
-            await this.action.run({
-                uri: this.model.uri,
-                $mid: 14
-            });
-        }
-        catch (error) {
-            console.warn(`Kernel source command failed: ${error}`);
-        }
-    }
-}
-let NotebookKernelService = class NotebookKernelService extends Disposable {
-    static { NotebookKernelService_1 = this; }
-    static { this._storageNotebookBinding = 'notebook.controller2NotebookBindings'; }
-    constructor(_notebookService, _storageService, _menuService, _contextKeyService) {
-        super();
-        this._notebookService = _notebookService;
-        this._storageService = _storageService;
-        this._menuService = _menuService;
-        this._contextKeyService = _contextKeyService;
-        this._kernels = ( new Map());
-        this._notebookBindings = ( new LRUCache(1000, 0.7));
-        this._onDidChangeNotebookKernelBinding = this._register(( new Emitter()));
-        this._onDidAddKernel = this._register(( new Emitter()));
-        this._onDidRemoveKernel = this._register(( new Emitter()));
-        this._onDidChangeNotebookAffinity = this._register(( new Emitter()));
-        this._onDidChangeSourceActions = this._register(( new Emitter()));
-        this._onDidNotebookVariablesChange = this._register(( new Emitter()));
-        this._kernelSources = ( new Map());
-        this._kernelSourceActionsUpdates = ( new Map());
-        this._kernelDetectionTasks = ( new Map());
-        this._onDidChangeKernelDetectionTasks = this._register(( new Emitter()));
-        this._kernelSourceActionProviders = ( new Map());
-        this.onDidChangeSelectedNotebooks = this._onDidChangeNotebookKernelBinding.event;
-        this.onDidAddKernel = this._onDidAddKernel.event;
-        this.onDidRemoveKernel = this._onDidRemoveKernel.event;
-        this.onDidChangeNotebookAffinity = this._onDidChangeNotebookAffinity.event;
-        this.onDidChangeSourceActions = this._onDidChangeSourceActions.event;
-        this.onDidChangeKernelDetectionTasks = this._onDidChangeKernelDetectionTasks.event;
-        this.onDidNotebookVariablesUpdate = this._onDidNotebookVariablesChange.event;
-        this._register(_notebookService.onDidAddNotebookDocument(this._tryAutoBindNotebook, this));
-        this._register(_notebookService.onWillRemoveNotebookDocument(notebook => {
-            const id = NotebookTextModelLikeId.str(notebook);
-            const kernelId = this._notebookBindings.get(id);
-            if (kernelId && notebook.uri.scheme === Schemas.untitled) {
-                this.selectKernelForNotebook(undefined, notebook);
-            }
-            this._kernelSourceActionsUpdates.get(id)?.dispose();
-            this._kernelSourceActionsUpdates.delete(id);
-        }));
-        try {
-            const data = JSON.parse(this._storageService.get(NotebookKernelService_1._storageNotebookBinding, 1 , '[]'));
-            this._notebookBindings.fromJSON(data);
-        }
-        catch {
-        }
-    }
-    dispose() {
-        this._kernels.clear();
-        this._kernelSources.forEach(v => {
-            v.menu.dispose();
-            v.actions.forEach(a => a[1].dispose());
-        });
-        this._kernelSourceActionsUpdates.forEach(v => {
-            v.dispose();
-        });
-        this._kernelSourceActionsUpdates.clear();
-        super.dispose();
-    }
-    _persistMementos() {
-        this._persistSoonHandle?.dispose();
-        this._persistSoonHandle = runWhenWindowIdle(getActiveWindow(), () => {
-            this._storageService.store(NotebookKernelService_1._storageNotebookBinding, JSON.stringify(this._notebookBindings), 1 , 1 );
-        }, 100);
-    }
-    static _score(kernel, notebook) {
-        if (kernel.viewType === '*') {
-            return 5;
-        }
-        else if (kernel.viewType === notebook.viewType) {
-            return 10;
-        }
-        else {
-            return 0;
-        }
-    }
-    _tryAutoBindNotebook(notebook, onlyThisKernel) {
-        const id = this._notebookBindings.get(NotebookTextModelLikeId.str(notebook));
-        if (!id) {
-            return;
-        }
-        const existingKernel = this._kernels.get(id);
-        if (!existingKernel || !NotebookKernelService_1._score(existingKernel.kernel, notebook)) {
-            return;
-        }
-        if (!onlyThisKernel || existingKernel.kernel === onlyThisKernel) {
-            this._onDidChangeNotebookKernelBinding.fire({ notebook: notebook.uri, oldKernel: undefined, newKernel: existingKernel.kernel.id });
-        }
-    }
-    notifyVariablesChange(notebookUri) {
-        this._onDidNotebookVariablesChange.fire(notebookUri);
-    }
-    registerKernel(kernel) {
-        if (( this._kernels.has(kernel.id))) {
-            throw new Error(`NOTEBOOK CONTROLLER with id '${kernel.id}' already exists`);
-        }
-        this._kernels.set(kernel.id, ( new KernelInfo(kernel)));
-        this._onDidAddKernel.fire(kernel);
-        for (const notebook of this._notebookService.getNotebookTextModels()) {
-            this._tryAutoBindNotebook(notebook, kernel);
-        }
-        return toDisposable(() => {
-            if (this._kernels.delete(kernel.id)) {
-                this._onDidRemoveKernel.fire(kernel);
-            }
-            for (const [key, candidate] of Array.from(this._notebookBindings)) {
-                if (candidate === kernel.id) {
-                    this._onDidChangeNotebookKernelBinding.fire({ notebook: NotebookTextModelLikeId.obj(key).uri, oldKernel: kernel.id, newKernel: undefined });
-                }
-            }
-        });
-    }
-    getMatchingKernel(notebook) {
-        const kernels = [];
-        for (const info of ( this._kernels.values())) {
-            const score = NotebookKernelService_1._score(info.kernel, notebook);
-            if (score) {
-                kernels.push({
-                    score,
-                    kernel: info.kernel,
-                    instanceAffinity: info.notebookPriorities.get(notebook.uri) ?? 1 ,
-                });
-            }
-        }
-        kernels
-            .sort((a, b) => b.instanceAffinity - a.instanceAffinity || a.score - b.score || a.kernel.label.localeCompare(b.kernel.label));
-        const all = ( kernels.map(obj => obj.kernel));
-        const selectedId = this._notebookBindings.get(NotebookTextModelLikeId.str(notebook));
-        const selected = selectedId ? this._kernels.get(selectedId)?.kernel : undefined;
-        const suggestions = ( kernels.filter(item => item.instanceAffinity > 1).map(item => item.kernel));
-        const hidden = ( kernels.filter(item => item.instanceAffinity < 0).map(item => item.kernel));
-        return { all, selected, suggestions, hidden };
-    }
-    getSelectedOrSuggestedKernel(notebook) {
-        const info = this.getMatchingKernel(notebook);
-        if (info.selected) {
-            return info.selected;
-        }
-        const preferred = info.all.filter(kernel => this._kernels.get(kernel.id)?.notebookPriorities.get(notebook.uri) === 2 );
-        if (preferred.length === 1) {
-            return preferred[0];
-        }
-        return info.all.length === 1 ? info.all[0] : undefined;
-    }
-    selectKernelForNotebook(kernel, notebook) {
-        const key = NotebookTextModelLikeId.str(notebook);
-        const oldKernel = this._notebookBindings.get(key);
-        if (oldKernel !== kernel?.id) {
-            if (kernel) {
-                this._notebookBindings.set(key, kernel.id);
-            }
-            else {
-                this._notebookBindings.delete(key);
-            }
-            this._onDidChangeNotebookKernelBinding.fire({ notebook: notebook.uri, oldKernel, newKernel: kernel?.id });
-            this._persistMementos();
-        }
-    }
-    preselectKernelForNotebook(kernel, notebook) {
-        const key = NotebookTextModelLikeId.str(notebook);
-        const oldKernel = this._notebookBindings.get(key);
-        if (oldKernel !== kernel?.id) {
-            this._notebookBindings.set(key, kernel.id);
-            this._persistMementos();
-        }
-    }
-    updateKernelNotebookAffinity(kernel, notebook, preference) {
-        const info = this._kernels.get(kernel.id);
-        if (!info) {
-            throw new Error(`UNKNOWN kernel '${kernel.id}'`);
-        }
-        if (preference === undefined) {
-            info.notebookPriorities.delete(notebook);
-        }
-        else {
-            info.notebookPriorities.set(notebook, preference);
-        }
-        this._onDidChangeNotebookAffinity.fire();
-    }
-    getRunningSourceActions(notebook) {
-        const id = NotebookTextModelLikeId.str(notebook);
-        const existingInfo = this._kernelSources.get(id);
-        if (existingInfo) {
-            return ( existingInfo.actions.filter(action => action[0].execution).map(action => action[0]));
-        }
-        return [];
-    }
-    getSourceActions(notebook, contextKeyService) {
-        contextKeyService = contextKeyService ?? this._contextKeyService;
-        const id = NotebookTextModelLikeId.str(notebook);
-        const existingInfo = this._kernelSources.get(id);
-        if (existingInfo) {
-            return ( existingInfo.actions.map(a => a[0]));
-        }
-        const sourceMenu = this._register(this._menuService.createMenu(MenuId.NotebookKernelSource, contextKeyService));
-        const info = { menu: sourceMenu, actions: [] };
-        const loadActionsFromMenu = (menu, document) => {
-            const groups = menu.getActions({ shouldForwardArgs: true });
-            const sourceActions = [];
-            groups.forEach(group => {
-                const isPrimary = /^primary/.test(group[0]);
-                group[1].forEach(action => {
-                    const sourceAction = ( new SourceAction(action, document, isPrimary));
-                    const stateChangeListener = sourceAction.onDidChangeState(() => {
-                        this._onDidChangeSourceActions.fire({
-                            notebook: document.uri,
-                            viewType: document.viewType,
-                        });
-                    });
-                    sourceActions.push([sourceAction, stateChangeListener]);
-                });
-            });
-            info.actions = sourceActions;
-            this._kernelSources.set(id, info);
-            this._onDidChangeSourceActions.fire({ notebook: document.uri, viewType: document.viewType });
-        };
-        this._kernelSourceActionsUpdates.get(id)?.dispose();
-        this._kernelSourceActionsUpdates.set(id, sourceMenu.onDidChange(() => {
-            loadActionsFromMenu(sourceMenu, notebook);
-        }));
-        loadActionsFromMenu(sourceMenu, notebook);
-        return ( info.actions.map(a => a[0]));
-    }
-    registerNotebookKernelDetectionTask(task) {
-        const notebookType = task.notebookType;
-        const all = this._kernelDetectionTasks.get(notebookType) ?? [];
-        all.push(task);
-        this._kernelDetectionTasks.set(notebookType, all);
-        this._onDidChangeKernelDetectionTasks.fire(notebookType);
-        return toDisposable(() => {
-            const all = this._kernelDetectionTasks.get(notebookType) ?? [];
-            const idx = all.indexOf(task);
-            if (idx >= 0) {
-                all.splice(idx, 1);
-                this._kernelDetectionTasks.set(notebookType, all);
-                this._onDidChangeKernelDetectionTasks.fire(notebookType);
-            }
-        });
-    }
-    getKernelDetectionTasks(notebook) {
-        return this._kernelDetectionTasks.get(notebook.viewType) ?? [];
-    }
-    registerKernelSourceActionProvider(viewType, provider) {
-        const providers = this._kernelSourceActionProviders.get(viewType) ?? [];
-        providers.push(provider);
-        this._kernelSourceActionProviders.set(viewType, providers);
-        this._onDidChangeSourceActions.fire({ viewType: viewType });
-        const eventEmitterDisposable = provider.onDidChangeSourceActions?.(() => {
-            this._onDidChangeSourceActions.fire({ viewType: viewType });
-        });
-        return toDisposable(() => {
-            const providers = this._kernelSourceActionProviders.get(viewType) ?? [];
-            const idx = providers.indexOf(provider);
-            if (idx >= 0) {
-                providers.splice(idx, 1);
-                this._kernelSourceActionProviders.set(viewType, providers);
-            }
-            eventEmitterDisposable?.dispose();
-        });
-    }
-    getKernelSourceActions2(notebook) {
-        const viewType = notebook.viewType;
-        const providers = this._kernelSourceActionProviders.get(viewType) ?? [];
-        const promises = ( providers.map(provider => provider.provideKernelSourceActions()));
-        return Promise.all(promises).then(actions => {
-            return actions.reduce((a, b) => a.concat(b), []);
-        });
-    }
-};
-NotebookKernelService = NotebookKernelService_1 = ( __decorate([
-    ( __param(0, INotebookService)),
-    ( __param(1, IStorageService)),
-    ( __param(2, IMenuService)),
-    ( __param(3, IContextKeyService))
-], NotebookKernelService));
-
-export { NotebookKernelService };

package/vscode/src/vs/workbench/contrib/notebook/browser/services/notebookKeymapServiceImpl.js

@@ -1,111 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { onUnexpectedError } from 'vscode/vscode/vs/base/common/errors';
-import { Event } from 'vscode/vscode/vs/base/common/event';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { Severity, INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
-import { getInstalledExtensions } from 'vscode/vscode/vs/workbench/contrib/extensions/common/extensionsUtils';
-import { IWorkbenchExtensionEnablementService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
-import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
-import { IExtensionManagementService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
-import { areSameExtensions } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import { Memento } from 'vscode/vscode/vs/workbench/common/memento';
-import { distinct } from 'vscode/vscode/vs/base/common/arrays';
-
-function onExtensionChanged(accessor) {
-    const extensionService = accessor.get(IExtensionManagementService);
-    const extensionEnablementService = accessor.get(IWorkbenchExtensionEnablementService);
-    const onDidInstallExtensions = Event.chain(extensionService.onDidInstallExtensions, $ => ( $.filter(e => ( e.some(({ operation }) => operation === 2 )))
-        .map(e => ( e.map(({ identifier }) => identifier)))));
-    return Event.debounce(Event.any(Event.any(onDidInstallExtensions, ( Event.map(extensionService.onDidUninstallExtension, e => [e.identifier]))), ( Event.map(
-        extensionEnablementService.onEnablementChanged,
-        extensions => ( extensions.map(e => e.identifier))
-    ))), (result, identifiers) => {
-        result = result || (identifiers.length ? [identifiers[0]] : []);
-        for (const identifier of identifiers) {
-            if (( result.some(l => !areSameExtensions(l, identifier)))) {
-                result.push(identifier);
-            }
-        }
-        return result;
-    });
-}
-const hasRecommendedKeymapKey = 'hasRecommendedKeymap';
-let NotebookKeymapService = class NotebookKeymapService extends Disposable {
-    constructor(instantiationService, extensionEnablementService, notificationService, storageService, lifecycleService) {
-        super();
-        this.instantiationService = instantiationService;
-        this.extensionEnablementService = extensionEnablementService;
-        this.notificationService = notificationService;
-        this.notebookKeymapMemento = ( new Memento('notebookKeymap', storageService));
-        this.notebookKeymap = this.notebookKeymapMemento.getMemento(0 , 0 );
-        this._register(lifecycleService.onDidShutdown(() => this.dispose()));
-        this._register(this.instantiationService.invokeFunction(onExtensionChanged)((identifiers => {
-            Promise.all(( identifiers.map(identifier => this.checkForOtherKeymaps(identifier))))
-                .then(undefined, onUnexpectedError);
-        })));
-    }
-    checkForOtherKeymaps(extensionIdentifier) {
-        return this.instantiationService.invokeFunction(getInstalledExtensions).then(extensions => {
-            const keymaps = extensions.filter(extension => isNotebookKeymapExtension(extension));
-            const extension = keymaps.find(extension => areSameExtensions(extension.identifier, extensionIdentifier));
-            if (extension && extension.globallyEnabled) {
-                this.notebookKeymap[hasRecommendedKeymapKey] = true;
-                this.notebookKeymapMemento.saveMemento();
-                const otherKeymaps = keymaps.filter(extension => !areSameExtensions(extension.identifier, extensionIdentifier) && extension.globallyEnabled);
-                if (otherKeymaps.length) {
-                    return this.promptForDisablingOtherKeymaps(extension, otherKeymaps);
-                }
-            }
-            return undefined;
-        });
-    }
-    promptForDisablingOtherKeymaps(newKeymap, oldKeymaps) {
-        const onPrompt = (confirmed) => {
-            if (confirmed) {
-                this.extensionEnablementService.setEnablement(( oldKeymaps.map(keymap => keymap.local)), 6 );
-            }
-        };
-        this.notificationService.prompt(Severity.Info, ( localizeWithPath(
-            'vs/workbench/contrib/notebook/browser/services/notebookKeymapServiceImpl',
-            'disableOtherKeymapsConfirmation',
-            "Disable other keymaps ({0}) to avoid conflicts between keybindings?",
-            ( distinct(( oldKeymaps.map(k => k.local.manifest.displayName))).map(name => `'${name}'`)).join(', ')
-        )), [{
-                label: ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/services/notebookKeymapServiceImpl',
-                    'yes',
-                    "Yes"
-                )),
-                run: () => onPrompt(true)
-            }, {
-                label: ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/services/notebookKeymapServiceImpl',
-                    'no',
-                    "No"
-                )),
-                run: () => onPrompt(false)
-            }]);
-    }
-};
-NotebookKeymapService = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IWorkbenchExtensionEnablementService)),
-    ( __param(2, INotificationService)),
-    ( __param(3, IStorageService)),
-    ( __param(4, ILifecycleService))
-], NotebookKeymapService));
-function isNotebookKeymapExtension(extension) {
-    if (extension.local.manifest.extensionPack) {
-        return false;
-    }
-    const keywords = extension.local.manifest.keywords;
-    if (!keywords) {
-        return false;
-    }
-    return keywords.indexOf('notebook-keymap') !== -1;
-}
-
-export { NotebookKeymapService, isNotebookKeymapExtension };

package/vscode/src/vs/workbench/contrib/notebook/browser/services/notebookLoggingServiceImpl.js

@@ -1,28 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { ILoggerService } from 'vscode/vscode/vs/platform/log/common/log';
-
-const logChannelId = 'notebook.rendering';
-let NotebookLoggingService = class NotebookLoggingService extends Disposable {
-    static { this.ID = 'notebook'; }
-    constructor(loggerService) {
-        super();
-        this._logger = this._register(loggerService.createLogger(logChannelId, { name: ( localizeWithPath(
-            'vs/workbench/contrib/notebook/browser/services/notebookLoggingServiceImpl',
-            'renderChannelName',
-            "Notebook rendering"
-        )) }));
-    }
-    debug(category, output) {
-        this._logger.debug(`[${category}] ${output}`);
-    }
-    info(category, output) {
-        this._logger.info(`[${category}] ${output}`);
-    }
-};
-NotebookLoggingService = ( __decorate([
-    ( __param(0, ILoggerService))
-], NotebookLoggingService));
-
-export { NotebookLoggingService };

package/vscode/src/vs/workbench/contrib/notebook/browser/services/notebookRendererMessagingServiceImpl.js

@@ -1,65 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
-
-let NotebookRendererMessagingService = class NotebookRendererMessagingService extends Disposable {
-    constructor(extensionService) {
-        super();
-        this.extensionService = extensionService;
-        this.activations = ( new Map());
-        this.scopedMessaging = ( new Map());
-        this.postMessageEmitter = this._register(( new Emitter()));
-        this.onShouldPostMessage = this.postMessageEmitter.event;
-    }
-    receiveMessage(editorId, rendererId, message) {
-        if (editorId === undefined) {
-            const sends = ( [...( this.scopedMessaging.values())].map(e => e.receiveMessageHandler?.(rendererId, message)));
-            return Promise.all(sends).then(s => ( s.some(s => !!s)));
-        }
-        return this.scopedMessaging.get(editorId)?.receiveMessageHandler?.(rendererId, message) ?? Promise.resolve(false);
-    }
-    prepare(rendererId) {
-        if (( this.activations.has(rendererId))) {
-            return;
-        }
-        const queue = [];
-        this.activations.set(rendererId, queue);
-        this.extensionService.activateByEvent(`onRenderer:${rendererId}`).then(() => {
-            for (const message of queue) {
-                this.postMessageEmitter.fire(message);
-            }
-            this.activations.set(rendererId, undefined);
-        });
-    }
-    getScoped(editorId) {
-        const existing = this.scopedMessaging.get(editorId);
-        if (existing) {
-            return existing;
-        }
-        const messaging = {
-            postMessage: (rendererId, message) => this.postMessage(editorId, rendererId, message),
-            dispose: () => this.scopedMessaging.delete(editorId),
-        };
-        this.scopedMessaging.set(editorId, messaging);
-        return messaging;
-    }
-    postMessage(editorId, rendererId, message) {
-        if (!( this.activations.has(rendererId))) {
-            this.prepare(rendererId);
-        }
-        const activation = this.activations.get(rendererId);
-        const toSend = { rendererId, editorId, message };
-        if (activation === undefined) {
-            this.postMessageEmitter.fire(toSend);
-        }
-        else {
-            activation.push(toSend);
-        }
-    }
-};
-NotebookRendererMessagingService = ( __decorate([
-    ( __param(0, IExtensionService))
-], NotebookRendererMessagingService));
-
-export { NotebookRendererMessagingService };