@codingame/monaco-vscode-api 4.1.0 → 4.1.2

package/vscode/src/vs/workbench/contrib/notebook/browser/notebookAccessibility.js

@@ -1,157 +0,0 @@
-import { localizeWithPath } from '../../../../nls.js';
-import { format } from '../../../../base/common/strings.js';
-import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.js';
-import { IAccessibleViewService } from '../../accessibility/browser/accessibleView.js';
-import { getNotebookEditorFromEditorPane } from './notebookBrowser.js';
-function getAccessibilityHelpText(accessor) {
-    const keybindingService = accessor.get(IKeybindingService);
-    const content = [];
-    content.push(( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
-        'notebook.overview',
-        'The notebook view is a collection of code and markdown cells. Code cells can be executed and will produce output directly below the cell.'
-    )));
-    content.push(descriptionForCommand('notebook.cell.edit', ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
-        'notebook.cell.edit',
-        'The Edit Cell command ({0}) will focus on the cell input.'
-    )), ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
-        'notebook.cell.editNoKb',
-        'The Edit Cell command will focus on the cell input and is currently not triggerable by a keybinding.'
-    )), keybindingService));
-    content.push(descriptionForCommand('notebook.cell.quitEdit', ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
-        'notebook.cell.quitEdit',
-        'The Quit Edit command ({0}) will set focus on the cell container. The default (Escape) key may need to be pressed twice first exit the virtual cursor if active.'
-    )), ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
-        'notebook.cell.quitEditNoKb',
-        'The Quit Edit command will set focus on the cell container and is currently not triggerable by a keybinding.'
-    )), keybindingService));
-    content.push(descriptionForCommand('notebook.cell.focusInOutput', ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
-        'notebook.cell.focusInOutput',
-        'The Focus Output command ({0}) will set focus in the cell\'s output.'
-    )), ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
-        'notebook.cell.focusInOutputNoKb',
-        'The Quit Edit command will set focus in the cell\'s output and is currently not triggerable by a keybinding.'
-    )), keybindingService));
-    content.push(descriptionForCommand('notebook.focusNextEditor', ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
-        'notebook.focusNextEditor',
-        'The Focus Next Cell Editor command ({0}) will set focus in the next cell\'s editor.'
-    )), ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
-        'notebook.focusNextEditorNoKb',
-        'The Focus Next Cell Editor command will set focus in the next cell\'s editor and is currently not triggerable by a keybinding.'
-    )), keybindingService));
-    content.push(descriptionForCommand('notebook.focusPreviousEditor', ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
-        'notebook.focusPreviousEditor',
-        'The Focus Previous Cell Editor command ({0}) will set focus in the previous cell\'s editor.'
-    )), ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
-        'notebook.focusPreviousEditorNoKb',
-        'The Focus Previous Cell Editor command will set focus in the previous cell\'s editor and is currently not triggerable by a keybinding.'
-    )), keybindingService));
-    content.push(( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
-        'notebook.cellNavigation',
-        'The up and down arrows will also move focus between cells while focused on the outer cell container.'
-    )));
-    content.push(descriptionForCommand('notebook.cell.executeAndFocusContainer', ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
-        'notebook.cell.executeAndFocusContainer',
-        'The Execute Cell command ({0}) executes the cell that currently has focus.'
-    )), ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
-        'notebook.cell.executeAndFocusContainerNoKb',
-        'The Execute Cell command executes the cell that currently has focus and is currently not triggerable by a keybinding.'
-    )), keybindingService));
-    content.push(( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
-        'notebook.cell.insertCodeCellBelowAndFocusContainer',
-        'The Insert Cell Above/Below commands will create new empty code cells'
-    )));
-    content.push(( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
-        'notebook.changeCellType',
-        'The Change Cell to Code/Markdown commands are used to switch between cell types.'
-    )));
-    return content.join('\n\n');
-}
-function descriptionForCommand(commandId, msg, noKbMsg, keybindingService) {
-    const kb = keybindingService.lookupKeybinding(commandId);
-    if (kb) {
-        return format(msg, kb.getAriaLabel());
-    }
-    return format(noKbMsg, commandId);
-}
-async function runAccessibilityHelpAction(accessor, editor) {
-    const accessibleViewService = accessor.get(IAccessibleViewService);
-    const helpText = getAccessibilityHelpText(accessor);
-    accessibleViewService.show({
-        id: "notebook" ,
-        verbositySettingKey: "accessibility.verbosity.notebook" ,
-        provideContent: () => helpText,
-        onClose: () => {
-            editor.focus();
-        },
-        options: { type: "help"  }
-    });
-}
-function showAccessibleOutput(accessibleViewService, editorService) {
-    const activePane = editorService.activeEditorPane;
-    const notebookEditor = getNotebookEditorFromEditorPane(activePane);
-    const notebookViewModel = notebookEditor?.getViewModel();
-    const selections = notebookViewModel?.getSelections();
-    const notebookDocument = notebookViewModel?.notebookDocument;
-    if (!selections || !notebookDocument || !notebookEditor?.textModel) {
-        return false;
-    }
-    const viewCell = notebookViewModel.viewCells[selections[0].start];
-    let outputContent = '';
-    const decoder = ( new TextDecoder());
-    for (let i = 0; i < viewCell.outputsViewModels.length; i++) {
-        const outputViewModel = viewCell.outputsViewModels[i];
-        const outputTextModel = viewCell.model.outputs[i];
-        const [mimeTypes, pick] = outputViewModel.resolveMimeTypes(notebookEditor.textModel, undefined);
-        const mimeType = mimeTypes[pick].mimeType;
-        let buffer = outputTextModel.outputs.find(output => output.mime === mimeType);
-        if (!buffer || mimeType.startsWith('image')) {
-            buffer = outputTextModel.outputs.find(output => !output.mime.startsWith('image'));
-        }
-        let text = `${mimeType}`;
-        if (buffer) {
-            const charLimit = 100_000;
-            text = decoder.decode(buffer.data.slice(0, charLimit).buffer);
-            if (buffer.data.byteLength > charLimit) {
-                text = text + '...(truncated)';
-            }
-            if (mimeType.endsWith('error')) {
-                text = text.replace(/\\u001b\[[0-9;]*m/gi, '').replaceAll('\\n', '\n');
-            }
-        }
-        const index = viewCell.outputsViewModels.length > 1
-            ? `Cell output ${i + 1} of ${viewCell.outputsViewModels.length}\n`
-            : '';
-        outputContent = outputContent.concat(`${index}${text}\n`);
-    }
-    if (!outputContent) {
-        return false;
-    }
-    accessibleViewService.show({
-        id: "notebook" ,
-        verbositySettingKey: "accessibility.verbosity.notebook" ,
-        provideContent() { return outputContent; },
-        onClose() {
-            notebookEditor?.setFocus(selections[0]);
-            activePane?.focus();
-        },
-        options: { type: "view"  }
-    });
-    return true;
-}
-export { getAccessibilityHelpText, runAccessibilityHelpAction, showAccessibleOutput };

package/vscode/src/vs/workbench/contrib/notebook/browser/notebookExtensionPoint.js

@@ -1,449 +0,0 @@
-import { localizeWithPath } from '../../../../nls.js';
-import { ExtensionsRegistry } from '../../../services/extensions/common/extensionsRegistry.js';
-import { NotebookEditorPriority } from '../common/notebookCommon.js';
-import { Disposable } from '../../../../base/common/lifecycle.js';
-import { SyncDescriptor } from '../../../../platform/instantiation/common/descriptors.js';
-import { Extensions } from '../../../services/extensionManagement/common/extensionFeatures.js';
-import { Registry } from '../../../../platform/registry/common/platform.js';
-const NotebookEditorContribution = ( Object.freeze({
-    type: 'type',
-    displayName: 'displayName',
-    selector: 'selector',
-    priority: 'priority',
-}));
-const NotebookRendererContribution = ( Object.freeze({
-    id: 'id',
-    displayName: 'displayName',
-    mimeTypes: 'mimeTypes',
-    entrypoint: 'entrypoint',
-    hardDependencies: 'dependencies',
-    optionalDependencies: 'optionalDependencies',
-    requiresMessaging: 'requiresMessaging',
-}));
-const NotebookPreloadContribution = ( Object.freeze({
-    type: 'type',
-    entrypoint: 'entrypoint',
-    localResourceRoots: 'localResourceRoots',
-}));
-const notebookProviderContribution = {
-    description: ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-        'contributes.notebook.provider',
-        'Contributes notebook document provider.'
-    )),
-    type: 'array',
-    defaultSnippets: [{ body: [{ type: '', displayName: '', 'selector': [{ 'filenamePattern': '' }] }] }],
-    items: {
-        type: 'object',
-        required: [
-            NotebookEditorContribution.type,
-            NotebookEditorContribution.displayName,
-            NotebookEditorContribution.selector,
-        ],
-        properties: {
-            [NotebookEditorContribution.type]: {
-                type: 'string',
-                description: ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                    'contributes.notebook.provider.viewType',
-                    'Type of the notebook.'
-                )),
-            },
-            [NotebookEditorContribution.displayName]: {
-                type: 'string',
-                description: ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                    'contributes.notebook.provider.displayName',
-                    'Human readable name of the notebook.'
-                )),
-            },
-            [NotebookEditorContribution.selector]: {
-                type: 'array',
-                description: ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                    'contributes.notebook.provider.selector',
-                    'Set of globs that the notebook is for.'
-                )),
-                items: {
-                    type: 'object',
-                    properties: {
-                        filenamePattern: {
-                            type: 'string',
-                            description: ( localizeWithPath(
-                                'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                                'contributes.notebook.provider.selector.filenamePattern',
-                                'Glob that the notebook is enabled for.'
-                            )),
-                        },
-                        excludeFileNamePattern: {
-                            type: 'string',
-                            description: ( localizeWithPath(
-                                'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                                'contributes.notebook.selector.provider.excludeFileNamePattern',
-                                'Glob that the notebook is disabled for.'
-                            ))
-                        }
-                    }
-                }
-            },
-            [NotebookEditorContribution.priority]: {
-                type: 'string',
-                markdownDeprecationMessage: ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                    'contributes.priority',
-                    'Controls if the custom editor is enabled automatically when the user opens a file. This may be overridden by users using the `workbench.editorAssociations` setting.'
-                )),
-                enum: [
-                    NotebookEditorPriority.default,
-                    NotebookEditorPriority.option,
-                ],
-                markdownEnumDescriptions: [
-                    ( localizeWithPath(
-                        'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                        'contributes.priority.default',
-                        'The editor is automatically used when the user opens a resource, provided that no other default custom editors are registered for that resource.'
-                    )),
-                    ( localizeWithPath(
-                        'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                        'contributes.priority.option',
-                        'The editor is not automatically used when the user opens a resource, but a user can switch to the editor using the `Reopen With` command.'
-                    )),
-                ],
-                default: 'default'
-            }
-        }
-    }
-};
-const defaultRendererSnippet = ( Object.freeze({ id: '', displayName: '', mimeTypes: [''], entrypoint: '' }));
-const notebookRendererContribution = {
-    description: ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-        'contributes.notebook.renderer',
-        'Contributes notebook output renderer provider.'
-    )),
-    type: 'array',
-    defaultSnippets: [{ body: [defaultRendererSnippet] }],
-    items: {
-        defaultSnippets: [{ body: defaultRendererSnippet }],
-        allOf: [
-            {
-                type: 'object',
-                required: [
-                    NotebookRendererContribution.id,
-                    NotebookRendererContribution.displayName,
-                ],
-                properties: {
-                    [NotebookRendererContribution.id]: {
-                        type: 'string',
-                        description: ( localizeWithPath(
-                            'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                            'contributes.notebook.renderer.viewType',
-                            'Unique identifier of the notebook output renderer.'
-                        )),
-                    },
-                    [NotebookRendererContribution.displayName]: {
-                        type: 'string',
-                        description: ( localizeWithPath(
-                            'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                            'contributes.notebook.renderer.displayName',
-                            'Human readable name of the notebook output renderer.'
-                        )),
-                    },
-                    [NotebookRendererContribution.hardDependencies]: {
-                        type: 'array',
-                        uniqueItems: true,
-                        items: { type: 'string' },
-                        markdownDescription: ( localizeWithPath(
-                            'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                            'contributes.notebook.renderer.hardDependencies',
-                            'List of kernel dependencies the renderer requires. If any of the dependencies are present in the `NotebookKernel.preloads`, the renderer can be used.'
-                        )),
-                    },
-                    [NotebookRendererContribution.optionalDependencies]: {
-                        type: 'array',
-                        uniqueItems: true,
-                        items: { type: 'string' },
-                        markdownDescription: ( localizeWithPath(
-                            'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                            'contributes.notebook.renderer.optionalDependencies',
-                            'List of soft kernel dependencies the renderer can make use of. If any of the dependencies are present in the `NotebookKernel.preloads`, the renderer will be preferred over renderers that don\'t interact with the kernel.'
-                        )),
-                    },
-                    [NotebookRendererContribution.requiresMessaging]: {
-                        default: 'never',
-                        enum: [
-                            'always',
-                            'optional',
-                            'never',
-                        ],
-                        enumDescriptions: [
-                            ( localizeWithPath(
-                                'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                                'contributes.notebook.renderer.requiresMessaging.always',
-                                'Messaging is required. The renderer will only be used when it\'s part of an extension that can be run in an extension host.'
-                            )),
-                            ( localizeWithPath(
-                                'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                                'contributes.notebook.renderer.requiresMessaging.optional',
-                                'The renderer is better with messaging available, but it\'s not requried.'
-                            )),
-                            ( localizeWithPath(
-                                'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                                'contributes.notebook.renderer.requiresMessaging.never',
-                                'The renderer does not require messaging.'
-                            )),
-                        ],
-                        description: ( localizeWithPath(
-                            'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                            'contributes.notebook.renderer.requiresMessaging',
-                            'Defines how and if the renderer needs to communicate with an extension host, via `createRendererMessaging`. Renderers with stronger messaging requirements may not work in all environments.'
-                        )),
-                    },
-                }
-            },
-            {
-                oneOf: [
-                    {
-                        required: [
-                            NotebookRendererContribution.entrypoint,
-                            NotebookRendererContribution.mimeTypes,
-                        ],
-                        properties: {
-                            [NotebookRendererContribution.mimeTypes]: {
-                                type: 'array',
-                                description: ( localizeWithPath(
-                                    'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                                    'contributes.notebook.selector',
-                                    'Set of globs that the notebook is for.'
-                                )),
-                                items: {
-                                    type: 'string'
-                                }
-                            },
-                            [NotebookRendererContribution.entrypoint]: {
-                                description: ( localizeWithPath(
-                                    'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                                    'contributes.notebook.renderer.entrypoint',
-                                    'File to load in the webview to render the extension.'
-                                )),
-                                type: 'string',
-                            },
-                        }
-                    },
-                    {
-                        required: [
-                            NotebookRendererContribution.entrypoint,
-                        ],
-                        properties: {
-                            [NotebookRendererContribution.entrypoint]: {
-                                description: ( localizeWithPath(
-                                    'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                                    'contributes.notebook.renderer.entrypoint',
-                                    'File to load in the webview to render the extension.'
-                                )),
-                                type: 'object',
-                                required: ['extends', 'path'],
-                                properties: {
-                                    extends: {
-                                        type: 'string',
-                                        description: ( localizeWithPath(
-                                            'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                                            'contributes.notebook.renderer.entrypoint.extends',
-                                            'Existing renderer that this one extends.'
-                                        )),
-                                    },
-                                    path: {
-                                        type: 'string',
-                                        description: ( localizeWithPath(
-                                            'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                                            'contributes.notebook.renderer.entrypoint',
-                                            'File to load in the webview to render the extension.'
-                                        )),
-                                    },
-                                }
-                            },
-                        }
-                    }
-                ]
-            }
-        ]
-    }
-};
-const notebookPreloadContribution = {
-    description: ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-        'contributes.preload.provider',
-        'Contributes notebook preloads.'
-    )),
-    type: 'array',
-    defaultSnippets: [{ body: [{ type: '', entrypoint: '' }] }],
-    items: {
-        type: 'object',
-        required: [
-            NotebookPreloadContribution.type,
-            NotebookPreloadContribution.entrypoint
-        ],
-        properties: {
-            [NotebookPreloadContribution.type]: {
-                type: 'string',
-                description: ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                    'contributes.preload.provider.viewType',
-                    'Type of the notebook.'
-                )),
-            },
-            [NotebookPreloadContribution.entrypoint]: {
-                type: 'string',
-                description: ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                    'contributes.preload.entrypoint',
-                    'Path to file loaded in the webview.'
-                )),
-            },
-            [NotebookPreloadContribution.localResourceRoots]: {
-                type: 'array',
-                items: { type: 'string' },
-                description: ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                    'contributes.preload.localResourceRoots',
-                    'Paths to additional resources that should be allowed in the webview.'
-                )),
-            },
-        }
-    }
-};
-const notebooksExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'notebooks',
-    jsonSchema: notebookProviderContribution,
-    activationEventsGenerator: (contribs, result) => {
-        for (const contrib of contribs) {
-            if (contrib.type) {
-                result.push(`onNotebookSerializer:${contrib.type}`);
-            }
-        }
-    }
-});
-const notebookRendererExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'notebookRenderer',
-    jsonSchema: notebookRendererContribution,
-    activationEventsGenerator: (contribs, result) => {
-        for (const contrib of contribs) {
-            if (contrib.id) {
-                result.push(`onRenderer:${contrib.id}`);
-            }
-        }
-    }
-});
-const notebookPreloadExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'notebookPreload',
-    jsonSchema: notebookPreloadContribution,
-});
-class NotebooksDataRenderer extends Disposable {
-    constructor() {
-        super(...arguments);
-        this.type = 'table';
-    }
-    shouldRender(manifest) {
-        return !!manifest.contributes?.notebooks;
-    }
-    render(manifest) {
-        const contrib = manifest.contributes?.notebooks || [];
-        if (!contrib.length) {
-            return { data: { headers: [], rows: [] }, dispose: () => { } };
-        }
-        const headers = [
-            ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                'Notebook id',
-                "ID"
-            )),
-            ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                'Notebook name',
-                "Name"
-            )),
-        ];
-        const rows = ( contrib
-            .sort((a, b) => a.type.localeCompare(b.type))
-            .map(notebook => {
-            return [
-                notebook.type,
-                notebook.displayName
-            ];
-        }));
-        return {
-            data: {
-                headers,
-                rows
-            },
-            dispose: () => { }
-        };
-    }
-}
-class NotebookRenderersDataRenderer extends Disposable {
-    constructor() {
-        super(...arguments);
-        this.type = 'table';
-    }
-    shouldRender(manifest) {
-        return !!manifest.contributes?.notebookRenderer;
-    }
-    render(manifest) {
-        const contrib = manifest.contributes?.notebookRenderer || [];
-        if (!contrib.length) {
-            return { data: { headers: [], rows: [] }, dispose: () => { } };
-        }
-        const headers = [
-            ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                'Notebook renderer name',
-                "Name"
-            )),
-            ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                'Notebook mimetypes',
-                "Mimetypes"
-            )),
-        ];
-        const rows = ( contrib
-            .sort((a, b) => a.displayName.localeCompare(b.displayName))
-            .map(notebookRenderer => {
-            return [
-                notebookRenderer.displayName,
-                notebookRenderer.mimeTypes.join(',')
-            ];
-        }));
-        return {
-            data: {
-                headers,
-                rows
-            },
-            dispose: () => { }
-        };
-    }
-}
-( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
-    id: 'notebooks',
-    label: ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-        'notebooks',
-        "Notebooks"
-    )),
-    access: {
-        canToggle: false
-    },
-    renderer: ( new SyncDescriptor(NotebooksDataRenderer)),
-});
-( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
-    id: 'notebookRenderer',
-    label: ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-        'notebookRenderer',
-        "Notebook Renderers"
-    )),
-    access: {
-        canToggle: false
-    },
-    renderer: ( new SyncDescriptor(NotebookRenderersDataRenderer)),
-});
-export { notebookPreloadExtensionPoint, notebookRendererExtensionPoint, notebooksExtensionPoint };