@codingame/monaco-vscode-notebook-service-override 1.85.1

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

@@ -0,0 +1,1121 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { Disposable, dispose, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { parse } from 'monaco-editor/esm/vs/base/common/marshalling.js';
+import { isEqual, extname } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { assertType } from 'monaco-editor/esm/vs/base/common/types.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { toFormattedString } from 'vscode/vscode/vs/base/common/jsonFormatter';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { EditorPaneDescriptor } from 'vscode/vscode/vs/workbench/browser/editor';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { EditorExtensions } from 'vscode/vscode/vs/workbench/common/editor';
+import { NotebookEditor } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditor';
+import { NotebookEditorInput } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorInput';
+import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
+import './services/notebookServiceImpl.js';
+import { NotebookSetting, CellUri, CellKind, NotebookWorkingCopyTypeIdentifier } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IUndoRedoService } from 'monaco-editor/esm/vs/platform/undoRedo/common/undoRedo.js';
+import { INotebookEditorModelResolverService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService';
+import { NotebookDiffEditorInput } from '../common/notebookDiffEditorInput.js';
+import { NotebookTextDiffEditor } from './diff/notebookDiffEditor.js';
+import './services/notebookWorkerServiceImpl.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import './services/notebookEditorServiceImpl.js';
+import { Extensions as Extensions$2 } from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
+import { getFormattedMetadataJSON, getStreamOutputData } from './diff/diffElementViewModel.js';
+import './services/notebookKernelServiceImpl.js';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { IWorkingCopyEditorService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyEditorService';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+import './services/notebookRendererMessagingServiceImpl.js';
+import 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/coreActions';
+import 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/insertCellActions';
+import './controller/executeActions.js';
+import './controller/layoutActions.js';
+import 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/editActions';
+import 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/cellOutputActions';
+import './controller/apiActions.js';
+import 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/foldingController';
+import './contrib/editorHint/emptyCellEditorHint.js';
+import './contrib/clipboard/notebookClipboard.js';
+import './contrib/find/notebookFind.js';
+import './contrib/format/formatting.js';
+import './contrib/saveParticipants/saveParticipants.js';
+import './contrib/gettingStarted/notebookGettingStarted.js';
+import './contrib/layout/layoutActions.js';
+import './contrib/marker/markerProvider.js';
+import './contrib/navigation/arrow.js';
+import './contrib/outline/notebookOutline.js';
+import './contrib/profile/notebookProfile.js';
+import './contrib/cellStatusBar/statusBarProviders.js';
+import './contrib/cellStatusBar/contributedStatusBarItemController.js';
+import './contrib/cellStatusBar/executionStatusBarItemController.js';
+import './contrib/editorStatusBar/editorStatusBar.js';
+import './contrib/undoRedo/notebookUndoRedo.js';
+import './contrib/cellCommands/cellCommands.js';
+import './contrib/viewportWarmup/viewportWarmup.js';
+import './contrib/troubleshoot/layout.js';
+import './contrib/debug/notebookBreakpoints.js';
+import './contrib/debug/notebookCellPausing.js';
+import './contrib/debug/notebookDebugDecorations.js';
+import './contrib/execute/executionEditorProgress.js';
+import './contrib/kernelDetection/notebookKernelDetection.js';
+import './diff/notebookDiffActions.js';
+import { editorOptionsRegistry } from 'monaco-editor/esm/vs/editor/common/config/editorOptions.js';
+import './services/notebookExecutionStateServiceImpl.js';
+import './services/notebookExecutionServiceImpl.js';
+import './services/notebookKeymapServiceImpl.js';
+import { PLAINTEXT_LANGUAGE_ID } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
+import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+import { COMMENTEDITOR_DECORATION_KEY } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentReply';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import './services/notebookKernelHistoryServiceImpl.js';
+import './services/notebookLoggingServiceImpl.js';
+import product from 'monaco-editor/esm/vs/platform/product/common/product.js';
+import { NOTEBOOK_IS_ACTIVE_EDITOR, NOTEBOOK_OUTPUT_FOCUSED } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
+import { runAccessibilityHelpAction, showAccessibleOutput } from './notebookAccessibility.js';
+import { IAccessibleViewService } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibleView';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { AccessibilityHelpAction, AccessibleViewAction } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibleViewActions';
+import { NotebookVariables } from './contrib/notebookVariables/notebookVariables.js';
+
+var NotebookContribution_1;
+( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(EditorPaneDescriptor.create(NotebookEditor, NotebookEditor.ID, 'Notebook Editor'), [
+    ( new SyncDescriptor(NotebookEditorInput))
+]);
+( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(EditorPaneDescriptor.create(NotebookTextDiffEditor, NotebookTextDiffEditor.ID, 'Notebook Diff Editor'), [
+    ( new SyncDescriptor(NotebookDiffEditorInput))
+]);
+class NotebookDiffEditorSerializer {
+    canSerialize() {
+        return true;
+    }
+    serialize(input) {
+        assertType(input instanceof NotebookDiffEditorInput);
+        return JSON.stringify({
+            resource: input.resource,
+            originalResource: input.original.resource,
+            name: input.getName(),
+            originalName: input.original.getName(),
+            textDiffName: input.getName(),
+            viewType: input.viewType,
+        });
+    }
+    deserialize(instantiationService, raw) {
+        const data = parse(raw);
+        if (!data) {
+            return undefined;
+        }
+        const { resource, originalResource, name, viewType } = data;
+        if (!data || !URI.isUri(resource) || !URI.isUri(originalResource) || typeof name !== 'string' || typeof viewType !== 'string') {
+            return undefined;
+        }
+        const input = NotebookDiffEditorInput.create(instantiationService, resource, name, undefined, originalResource, viewType);
+        return input;
+    }
+    static canResolveBackup(editorInput, backupResource) {
+        return false;
+    }
+}
+class NotebookEditorSerializer {
+    canSerialize() {
+        return true;
+    }
+    serialize(input) {
+        assertType(input instanceof NotebookEditorInput);
+        const data = {
+            resource: input.resource,
+            preferredResource: input.preferredResource,
+            viewType: input.viewType,
+            options: input.options
+        };
+        return JSON.stringify(data);
+    }
+    deserialize(instantiationService, raw) {
+        const data = parse(raw);
+        if (!data) {
+            return undefined;
+        }
+        const { resource, preferredResource, viewType, options } = data;
+        if (!data || !URI.isUri(resource) || typeof viewType !== 'string') {
+            return undefined;
+        }
+        const input = NotebookEditorInput.getOrCreate(instantiationService, resource, preferredResource, viewType, options);
+        return input;
+    }
+}
+( Registry.as(EditorExtensions.EditorFactory)).registerEditorSerializer(NotebookEditorInput.ID, NotebookEditorSerializer);
+( Registry.as(EditorExtensions.EditorFactory)).registerEditorSerializer(NotebookDiffEditorInput.ID, NotebookDiffEditorSerializer);
+let NotebookContribution = NotebookContribution_1 = class NotebookContribution extends Disposable {
+    constructor(undoRedoService, configurationService, codeEditorService) {
+        super();
+        this.codeEditorService = codeEditorService;
+        this.updateCellUndoRedoComparisonKey(configurationService, undoRedoService);
+        this._register(configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(NotebookSetting.undoRedoPerCell)) {
+                this.updateCellUndoRedoComparisonKey(configurationService, undoRedoService);
+            }
+        }));
+        this.codeEditorService.registerDecorationType('comment-controller', COMMENTEDITOR_DECORATION_KEY, {});
+    }
+    updateCellUndoRedoComparisonKey(configurationService, undoRedoService) {
+        const undoRedoPerCell = configurationService.getValue(NotebookSetting.undoRedoPerCell);
+        if (!undoRedoPerCell) {
+            if (!this._uriComparisonKeyComputer) {
+                this._uriComparisonKeyComputer = undoRedoService.registerUriComparisonKeyComputer(CellUri.scheme, {
+                    getComparisonKey: (uri) => {
+                        if (undoRedoPerCell) {
+                            return ( uri.toString());
+                        }
+                        return NotebookContribution_1._getCellUndoRedoComparisonKey(uri);
+                    }
+                });
+            }
+        }
+        else {
+            this._uriComparisonKeyComputer?.dispose();
+            this._uriComparisonKeyComputer = undefined;
+        }
+    }
+    static _getCellUndoRedoComparisonKey(uri) {
+        const data = CellUri.parse(uri);
+        if (!data) {
+            return ( uri.toString());
+        }
+        return ( data.notebook.toString());
+    }
+    dispose() {
+        super.dispose();
+        this._uriComparisonKeyComputer?.dispose();
+    }
+};
+NotebookContribution = NotebookContribution_1 = ( __decorate([
+    ( __param(0, IUndoRedoService)),
+    ( __param(1, IConfigurationService)),
+    ( __param(2, ICodeEditorService))
+], NotebookContribution));
+let CellContentProvider = class CellContentProvider {
+    constructor(textModelService, _modelService, _languageService, _notebookModelResolverService) {
+        this._modelService = _modelService;
+        this._languageService = _languageService;
+        this._notebookModelResolverService = _notebookModelResolverService;
+        this._registration = textModelService.registerTextModelContentProvider(CellUri.scheme, this);
+    }
+    dispose() {
+        this._registration.dispose();
+    }
+    async provideTextContent(resource) {
+        const existing = this._modelService.getModel(resource);
+        if (existing) {
+            return existing;
+        }
+        const data = CellUri.parse(resource);
+        if (!data) {
+            return null;
+        }
+        const ref = await this._notebookModelResolverService.resolve(data.notebook);
+        let result = null;
+        if (!ref.object.isResolved()) {
+            return null;
+        }
+        for (const cell of ref.object.notebook.cells) {
+            if (( cell.uri.toString()) === ( resource.toString())) {
+                const bufferFactory = {
+                    create: (defaultEOL) => {
+                        const newEOL = (defaultEOL === 2  ? '\r\n' : '\n');
+                        cell.textBuffer.setEOL(newEOL);
+                        return { textBuffer: cell.textBuffer, disposable: Disposable.None };
+                    },
+                    getFirstLineText: (limit) => {
+                        return cell.textBuffer.getLineContent(1).substring(0, limit);
+                    }
+                };
+                const languageId = this._languageService.getLanguageIdByLanguageName(cell.language);
+                const languageSelection = languageId ? this._languageService.createById(languageId) : (cell.cellKind === CellKind.Markup ? this._languageService.createById('markdown') : this._languageService.createByFilepathOrFirstLine(resource, cell.textBuffer.getLineContent(1)));
+                result = this._modelService.createModel(bufferFactory, languageSelection, resource);
+                break;
+            }
+        }
+        if (!result) {
+            ref.dispose();
+            return null;
+        }
+        const once = Event.any(result.onWillDispose, ref.object.notebook.onWillDispose)(() => {
+            once.dispose();
+            ref.dispose();
+        });
+        return result;
+    }
+};
+CellContentProvider = ( __decorate([
+    ( __param(0, ITextModelService)),
+    ( __param(1, IModelService)),
+    ( __param(2, ILanguageService)),
+    ( __param(3, INotebookEditorModelResolverService))
+], CellContentProvider));
+let CellInfoContentProvider = class CellInfoContentProvider {
+    constructor(textModelService, _modelService, _languageService, _labelService, _notebookModelResolverService) {
+        this._modelService = _modelService;
+        this._languageService = _languageService;
+        this._labelService = _labelService;
+        this._notebookModelResolverService = _notebookModelResolverService;
+        this._disposables = [];
+        this._disposables.push(textModelService.registerTextModelContentProvider(Schemas.vscodeNotebookCellMetadata, {
+            provideTextContent: this.provideMetadataTextContent.bind(this)
+        }));
+        this._disposables.push(textModelService.registerTextModelContentProvider(Schemas.vscodeNotebookCellOutput, {
+            provideTextContent: this.provideOutputTextContent.bind(this)
+        }));
+        this._disposables.push(this._labelService.registerFormatter({
+            scheme: Schemas.vscodeNotebookCellMetadata,
+            formatting: {
+                label: '${path} (metadata)',
+                separator: '/'
+            }
+        }));
+        this._disposables.push(this._labelService.registerFormatter({
+            scheme: Schemas.vscodeNotebookCellOutput,
+            formatting: {
+                label: '${path} (output)',
+                separator: '/'
+            }
+        }));
+    }
+    dispose() {
+        dispose(this._disposables);
+    }
+    async provideMetadataTextContent(resource) {
+        const existing = this._modelService.getModel(resource);
+        if (existing) {
+            return existing;
+        }
+        const data = CellUri.parseCellPropertyUri(resource, Schemas.vscodeNotebookCellMetadata);
+        if (!data) {
+            return null;
+        }
+        const ref = await this._notebookModelResolverService.resolve(data.notebook);
+        let result = null;
+        const mode = this._languageService.createById('json');
+        for (const cell of ref.object.notebook.cells) {
+            if (cell.handle === data.handle) {
+                const metadataSource = getFormattedMetadataJSON(ref.object.notebook, cell.metadata, cell.language);
+                result = this._modelService.createModel(metadataSource, mode, resource);
+                break;
+            }
+        }
+        if (!result) {
+            ref.dispose();
+            return null;
+        }
+        const once = result.onWillDispose(() => {
+            once.dispose();
+            ref.dispose();
+        });
+        return result;
+    }
+    parseStreamOutput(op) {
+        if (!op) {
+            return;
+        }
+        const streamOutputData = getStreamOutputData(op.outputs);
+        if (streamOutputData) {
+            return {
+                content: streamOutputData,
+                mode: this._languageService.createById(PLAINTEXT_LANGUAGE_ID)
+            };
+        }
+        return;
+    }
+    _getResult(data, cell) {
+        let result = undefined;
+        const mode = this._languageService.createById('json');
+        const op = cell.outputs.find(op => op.outputId === data.outputId || op.alternativeOutputId === data.outputId);
+        const streamOutputData = this.parseStreamOutput(op);
+        if (streamOutputData) {
+            result = streamOutputData;
+            return result;
+        }
+        const obj = ( cell.outputs.map(output => ({
+            metadata: output.metadata,
+            outputItems: ( output.outputs.map(opit => ({
+                mimeType: opit.mime,
+                data: ( opit.data.toString())
+            })))
+        })));
+        const outputSource = toFormattedString(obj, {});
+        result = {
+            content: outputSource,
+            mode
+        };
+        return result;
+    }
+    async provideOutputTextContent(resource) {
+        const existing = this._modelService.getModel(resource);
+        if (existing) {
+            return existing;
+        }
+        const data = CellUri.parseCellOutputUri(resource);
+        if (!data) {
+            return null;
+        }
+        const ref = await this._notebookModelResolverService.resolve(data.notebook);
+        const cell = ref.object.notebook.cells.find(cell => !!cell.outputs.find(op => op.outputId === data.outputId || op.alternativeOutputId === data.outputId));
+        if (!cell) {
+            ref.dispose();
+            return null;
+        }
+        const result = this._getResult(data, cell);
+        if (!result) {
+            ref.dispose();
+            return null;
+        }
+        const model = this._modelService.createModel(result.content, result.mode, resource);
+        const cellModelListener = Event.any(cell.onDidChangeOutputs ?? Event.None, cell.onDidChangeOutputItems ?? Event.None)(() => {
+            const newResult = this._getResult(data, cell);
+            if (!newResult) {
+                return;
+            }
+            model.setValue(newResult.content);
+            model.setLanguage(newResult.mode.languageId);
+        });
+        const once = model.onWillDispose(() => {
+            once.dispose();
+            cellModelListener.dispose();
+            ref.dispose();
+        });
+        return model;
+    }
+};
+CellInfoContentProvider = ( __decorate([
+    ( __param(0, ITextModelService)),
+    ( __param(1, IModelService)),
+    ( __param(2, ILanguageService)),
+    ( __param(3, ILabelService)),
+    ( __param(4, INotebookEditorModelResolverService))
+], CellInfoContentProvider));
+class RegisterSchemasContribution extends Disposable {
+    constructor() {
+        super();
+        this.registerMetadataSchemas();
+    }
+    registerMetadataSchemas() {
+        const jsonRegistry = ( Registry.as(Extensions$2.JSONContribution));
+        const metadataSchema = {
+            properties: {
+                ['language']: {
+                    type: 'string',
+                    description: 'The language for the cell'
+                }
+            },
+            additionalProperties: true,
+            allowTrailingCommas: true,
+            allowComments: true
+        };
+        jsonRegistry.registerSchema('vscode://schemas/notebook/cellmetadata', metadataSchema);
+    }
+}
+let NotebookEditorManager = class NotebookEditorManager {
+    constructor(_editorService, _notebookEditorModelService, editorGroups) {
+        this._editorService = _editorService;
+        this._notebookEditorModelService = _notebookEditorModelService;
+        this._disposables = ( new DisposableStore());
+        this._disposables.add(Event.debounce(this._notebookEditorModelService.onDidChangeDirty, (last, current) => !last ? [current] : [...last, current], 100)(this._openMissingDirtyNotebookEditors, this));
+        this._disposables.add(_notebookEditorModelService.onWillFailWithConflict(e => {
+            for (const group of editorGroups.groups) {
+                const conflictInputs = group.editors.filter(input => input instanceof NotebookEditorInput && input.viewType !== e.viewType && isEqual(input.resource, e.resource));
+                const p = group.closeEditors(conflictInputs);
+                e.waitUntil(p);
+            }
+        }));
+    }
+    dispose() {
+        this._disposables.dispose();
+    }
+    _openMissingDirtyNotebookEditors(models) {
+        const result = [];
+        for (const model of models) {
+            if (model.isDirty() && !this._editorService.isOpened({ resource: model.resource, typeId: NotebookEditorInput.ID, editorId: model.viewType }) && extname(model.resource) !== '.interactive') {
+                result.push({
+                    resource: model.resource,
+                    options: { inactive: true, preserveFocus: true, pinned: true, override: model.viewType }
+                });
+            }
+        }
+        if (result.length > 0) {
+            this._editorService.openEditors(result);
+        }
+    }
+};
+NotebookEditorManager = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, INotebookEditorModelResolverService)),
+    ( __param(2, IEditorGroupsService))
+], NotebookEditorManager));
+let SimpleNotebookWorkingCopyEditorHandler = class SimpleNotebookWorkingCopyEditorHandler extends Disposable {
+    constructor(_instantiationService, _workingCopyEditorService, _extensionService, _notebookService) {
+        super();
+        this._instantiationService = _instantiationService;
+        this._workingCopyEditorService = _workingCopyEditorService;
+        this._extensionService = _extensionService;
+        this._notebookService = _notebookService;
+        this._installHandler();
+    }
+    async handles(workingCopy) {
+        const viewType = this.handlesSync(workingCopy);
+        if (!viewType) {
+            return false;
+        }
+        return this._notebookService.canResolve(viewType);
+    }
+    handlesSync(workingCopy) {
+        const viewType = this._getViewType(workingCopy);
+        if (!viewType || viewType === 'interactive') {
+            return undefined;
+        }
+        return viewType;
+    }
+    isOpen(workingCopy, editor) {
+        if (!this.handlesSync(workingCopy)) {
+            return false;
+        }
+        return editor instanceof NotebookEditorInput && editor.viewType === this._getViewType(workingCopy) && isEqual(workingCopy.resource, editor.resource);
+    }
+    createEditor(workingCopy) {
+        return NotebookEditorInput.getOrCreate(this._instantiationService, workingCopy.resource, undefined, this._getViewType(workingCopy));
+    }
+    async _installHandler() {
+        await this._extensionService.whenInstalledExtensionsRegistered();
+        this._register(this._workingCopyEditorService.registerHandler(this));
+    }
+    _getViewType(workingCopy) {
+        return NotebookWorkingCopyTypeIdentifier.parse(workingCopy.typeId);
+    }
+};
+SimpleNotebookWorkingCopyEditorHandler = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IWorkingCopyEditorService)),
+    ( __param(2, IExtensionService)),
+    ( __param(3, INotebookService))
+], SimpleNotebookWorkingCopyEditorHandler));
+let NotebookLanguageSelectorScoreRefine = class NotebookLanguageSelectorScoreRefine {
+    constructor(_notebookService, languageFeaturesService) {
+        this._notebookService = _notebookService;
+        languageFeaturesService.setNotebookTypeResolver(this._getNotebookInfo.bind(this));
+    }
+    _getNotebookInfo(uri) {
+        const cellUri = CellUri.parse(uri);
+        if (!cellUri) {
+            return undefined;
+        }
+        const notebook = this._notebookService.getNotebookTextModel(cellUri.notebook);
+        if (!notebook) {
+            return undefined;
+        }
+        return {
+            uri: notebook.uri,
+            type: notebook.viewType
+        };
+    }
+};
+NotebookLanguageSelectorScoreRefine = ( __decorate([
+    ( __param(0, INotebookService)),
+    ( __param(1, ILanguageFeaturesService))
+], NotebookLanguageSelectorScoreRefine));
+class NotebookAccessibilityHelpContribution extends Disposable {
+    constructor() {
+        super();
+        this._register(AccessibilityHelpAction.addImplementation(105, 'notebook', async (accessor) => {
+            const codeEditor = accessor.get(ICodeEditorService).getActiveCodeEditor() || accessor.get(ICodeEditorService).getFocusedCodeEditor();
+            if (!codeEditor) {
+                return;
+            }
+            runAccessibilityHelpAction(accessor, codeEditor);
+        }, NOTEBOOK_IS_ACTIVE_EDITOR));
+    }
+}
+class NotebookAccessibleViewContribution extends Disposable {
+    constructor() {
+        super();
+        this._register(AccessibleViewAction.addImplementation(100, 'notebook', accessor => {
+            const accessibleViewService = accessor.get(IAccessibleViewService);
+            const editorService = accessor.get(IEditorService);
+            return showAccessibleOutput(accessibleViewService, editorService);
+        }, ( ContextKeyExpr.and(NOTEBOOK_OUTPUT_FOCUSED, ( ContextKeyExpr.equals('resourceExtname', '.ipynb'))))));
+    }
+}
+const workbenchContributionsRegistry = ( Registry.as(Extensions.Workbench));
+workbenchContributionsRegistry.registerWorkbenchContribution(NotebookContribution, 1 );
+workbenchContributionsRegistry.registerWorkbenchContribution(CellContentProvider, 1 );
+workbenchContributionsRegistry.registerWorkbenchContribution(CellInfoContentProvider, 1 );
+workbenchContributionsRegistry.registerWorkbenchContribution(RegisterSchemasContribution, 1 );
+workbenchContributionsRegistry.registerWorkbenchContribution(NotebookEditorManager, 2 );
+workbenchContributionsRegistry.registerWorkbenchContribution(NotebookLanguageSelectorScoreRefine, 2 );
+workbenchContributionsRegistry.registerWorkbenchContribution(SimpleNotebookWorkingCopyEditorHandler, 2 );
+workbenchContributionsRegistry.registerWorkbenchContribution(NotebookAccessibilityHelpContribution, 4 );
+workbenchContributionsRegistry.registerWorkbenchContribution(NotebookAccessibleViewContribution, 4 );
+workbenchContributionsRegistry.registerWorkbenchContribution(NotebookVariables, 4 );
+const schemas = {};
+function isConfigurationPropertySchema(x) {
+    return (typeof x.type !== 'undefined' || typeof x.anyOf !== 'undefined');
+}
+for (const editorOption of editorOptionsRegistry) {
+    const schema = editorOption.schema;
+    if (schema) {
+        if (isConfigurationPropertySchema(schema)) {
+            schemas[`editor.${editorOption.name}`] = schema;
+        }
+        else {
+            for (const key in schema) {
+                if (Object.hasOwnProperty.call(schema, key)) {
+                    schemas[key] = schema[key];
+                }
+            }
+        }
+    }
+}
+const editorOptionsCustomizationSchema = {
+    description: ( nls.localizeWithPath(
+        'vs/workbench/contrib/notebook/browser/notebook.contribution',
+        'notebook.editorOptions.experimentalCustomization',
+        'Settings for code editors used in notebooks. This can be used to customize most editor.* settings.'
+    )),
+    default: {},
+    allOf: [
+        {
+            properties: schemas,
+        }
+    ],
+    tags: ['notebookLayout']
+};
+const configurationRegistry = ( Registry.as(Extensions$1.Configuration));
+configurationRegistry.registerConfiguration({
+    id: 'notebook',
+    order: 100,
+    title: ( nls.localizeWithPath(
+        'vs/workbench/contrib/notebook/browser/notebook.contribution',
+        'notebookConfigurationTitle',
+        "Notebook"
+    )),
+    type: 'object',
+    properties: {
+        [NotebookSetting.displayOrder]: {
+            description: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.displayOrder.description',
+                "Priority list for output mime types"
+            )),
+            type: 'array',
+            items: {
+                type: 'string'
+            },
+            default: []
+        },
+        [NotebookSetting.cellToolbarLocation]: {
+            description: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.cellToolbarLocation.description',
+                "Where the cell toolbar should be shown, or whether it should be hidden."
+            )),
+            type: 'object',
+            additionalProperties: {
+                markdownDescription: ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                    'notebook.cellToolbarLocation.viewType',
+                    "Configure the cell toolbar position for for specific file types"
+                )),
+                type: 'string',
+                enum: ['left', 'right', 'hidden']
+            },
+            default: {
+                'default': 'right'
+            },
+            tags: ['notebookLayout']
+        },
+        [NotebookSetting.showCellStatusBar]: {
+            description: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.showCellStatusbar.description',
+                "Whether the cell status bar should be shown."
+            )),
+            type: 'string',
+            enum: ['hidden', 'visible', 'visibleAfterExecute'],
+            enumDescriptions: [
+                ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                    'notebook.showCellStatusbar.hidden.description',
+                    "The cell Status bar is always hidden."
+                )),
+                ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                    'notebook.showCellStatusbar.visible.description',
+                    "The cell Status bar is always visible."
+                )),
+                ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                    'notebook.showCellStatusbar.visibleAfterExecute.description',
+                    "The cell Status bar is hidden until the cell has executed. Then it becomes visible to show the execution status."
+                ))
+            ],
+            default: 'visible',
+            tags: ['notebookLayout']
+        },
+        [NotebookSetting.textDiffEditorPreview]: {
+            description: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.diff.enablePreview.description',
+                "Whether to use the enhanced text diff editor for notebook."
+            )),
+            type: 'boolean',
+            default: true,
+            tags: ['notebookLayout']
+        },
+        [NotebookSetting.diffOverviewRuler]: {
+            description: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.diff.enableOverviewRuler.description',
+                "Whether to render the overview ruler in the diff editor for notebook."
+            )),
+            type: 'boolean',
+            default: false,
+            tags: ['notebookLayout']
+        },
+        [NotebookSetting.cellToolbarVisibility]: {
+            markdownDescription: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.cellToolbarVisibility.description',
+                "Whether the cell toolbar should appear on hover or click."
+            )),
+            type: 'string',
+            enum: ['hover', 'click'],
+            default: 'click',
+            tags: ['notebookLayout']
+        },
+        [NotebookSetting.undoRedoPerCell]: {
+            description: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.undoRedoPerCell.description',
+                "Whether to use separate undo/redo stack for each cell."
+            )),
+            type: 'boolean',
+            default: true,
+            tags: ['notebookLayout']
+        },
+        [NotebookSetting.compactView]: {
+            description: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.compactView.description',
+                "Control whether the notebook editor should be rendered in a compact form. For example, when turned on, it will decrease the left margin width."
+            )),
+            type: 'boolean',
+            default: true,
+            tags: ['notebookLayout']
+        },
+        [NotebookSetting.focusIndicator]: {
+            description: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.focusIndicator.description',
+                "Controls where the focus indicator is rendered, either along the cell borders or on the left gutter."
+            )),
+            type: 'string',
+            enum: ['border', 'gutter'],
+            default: 'gutter',
+            tags: ['notebookLayout']
+        },
+        [NotebookSetting.insertToolbarLocation]: {
+            description: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.insertToolbarPosition.description',
+                "Control where the insert cell actions should appear."
+            )),
+            type: 'string',
+            enum: ['betweenCells', 'notebookToolbar', 'both', 'hidden'],
+            enumDescriptions: [
+                ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                    'insertToolbarLocation.betweenCells',
+                    "A toolbar that appears on hover between cells."
+                )),
+                ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                    'insertToolbarLocation.notebookToolbar',
+                    "The toolbar at the top of the notebook editor."
+                )),
+                ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                    'insertToolbarLocation.both',
+                    "Both toolbars."
+                )),
+                ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                    'insertToolbarLocation.hidden',
+                    "The insert actions don't appear anywhere."
+                )),
+            ],
+            default: 'both',
+            tags: ['notebookLayout']
+        },
+        [NotebookSetting.globalToolbar]: {
+            description: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.globalToolbar.description',
+                "Control whether to render a global toolbar inside the notebook editor."
+            )),
+            type: 'boolean',
+            default: true,
+            tags: ['notebookLayout']
+        },
+        [NotebookSetting.stickyScroll]: {
+            description: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.stickyScroll.description',
+                "Experimental. Control whether to render notebook Sticky Scroll headers in the notebook editor."
+            )),
+            type: 'boolean',
+            default: false,
+            tags: ['notebookLayout']
+        },
+        [NotebookSetting.consolidatedOutputButton]: {
+            description: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.consolidatedOutputButton.description',
+                "Control whether outputs action should be rendered in the output toolbar."
+            )),
+            type: 'boolean',
+            default: true,
+            tags: ['notebookLayout']
+        },
+        [NotebookSetting.showFoldingControls]: {
+            description: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.showFoldingControls.description',
+                "Controls when the Markdown header folding arrow is shown."
+            )),
+            type: 'string',
+            enum: ['always', 'never', 'mouseover'],
+            enumDescriptions: [
+                ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                    'showFoldingControls.always',
+                    "The folding controls are always visible."
+                )),
+                ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                    'showFoldingControls.never',
+                    "Never show the folding controls and reduce the gutter size."
+                )),
+                ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                    'showFoldingControls.mouseover',
+                    "The folding controls are visible only on mouseover."
+                )),
+            ],
+            default: 'mouseover',
+            tags: ['notebookLayout']
+        },
+        [NotebookSetting.dragAndDropEnabled]: {
+            description: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.dragAndDrop.description',
+                "Control whether the notebook editor should allow moving cells through drag and drop."
+            )),
+            type: 'boolean',
+            default: true,
+            tags: ['notebookLayout']
+        },
+        [NotebookSetting.consolidatedRunButton]: {
+            description: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.consolidatedRunButton.description',
+                "Control whether extra actions are shown in a dropdown next to the run button."
+            )),
+            type: 'boolean',
+            default: false,
+            tags: ['notebookLayout']
+        },
+        [NotebookSetting.globalToolbarShowLabel]: {
+            description: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.globalToolbarShowLabel',
+                "Control whether the actions on the notebook toolbar should render label or not."
+            )),
+            type: 'string',
+            enum: ['always', 'never', 'dynamic'],
+            default: 'always',
+            tags: ['notebookLayout']
+        },
+        [NotebookSetting.textOutputLineLimit]: {
+            markdownDescription: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.textOutputLineLimit',
+                "Controls how many lines of text are displayed in a text output. If {0} is enabled, this setting is used to determine the scroll height of the output.",
+                '`#notebook.output.scrolling#`'
+            )),
+            type: 'number',
+            default: 30,
+            tags: ['notebookLayout', 'notebookOutputLayout']
+        },
+        [NotebookSetting.markupFontSize]: {
+            markdownDescription: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.markup.fontSize',
+                "Controls the font size in pixels of rendered markup in notebooks. When set to {0}, 120% of {1} is used.",
+                '`0`',
+                '`#editor.fontSize#`'
+            )),
+            type: 'number',
+            default: 0,
+            tags: ['notebookLayout']
+        },
+        [NotebookSetting.cellEditorOptionsCustomizations]: editorOptionsCustomizationSchema,
+        [NotebookSetting.interactiveWindowCollapseCodeCells]: {
+            markdownDescription: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.interactiveWindow.collapseCodeCells',
+                "Controls whether code cells in the interactive window are collapsed by default."
+            )),
+            type: 'string',
+            enum: ['always', 'never', 'fromEditor'],
+            default: 'fromEditor'
+        },
+        [NotebookSetting.outputLineHeight]: {
+            markdownDescription: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.outputLineHeight',
+                "Line height of the output text within notebook cells.\n - When set to 0, editor line height is used.\n - Values between 0 and 8 will be used as a multiplier with the font size.\n - Values greater than or equal to 8 will be used as effective values."
+            )),
+            type: 'number',
+            default: 0,
+            tags: ['notebookLayout', 'notebookOutputLayout']
+        },
+        [NotebookSetting.outputFontSize]: {
+            markdownDescription: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.outputFontSize',
+                "Font size for the output text within notebook cells. When set to 0, {0} is used.",
+                '`#editor.fontSize#`'
+            )),
+            type: 'number',
+            default: 0,
+            tags: ['notebookLayout', 'notebookOutputLayout']
+        },
+        [NotebookSetting.outputFontFamily]: {
+            markdownDescription: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.outputFontFamily',
+                "The font family of the output text within notebook cells. When set to empty, the {0} is used.",
+                '`#editor.fontFamily#`'
+            )),
+            type: 'string',
+            tags: ['notebookLayout', 'notebookOutputLayout']
+        },
+        [NotebookSetting.outputScrolling]: {
+            markdownDescription: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.outputScrolling',
+                "Initially render notebook outputs in a scrollable region when longer than the limit."
+            )),
+            type: 'boolean',
+            tags: ['notebookLayout', 'notebookOutputLayout'],
+            default: typeof product.quality === 'string' && product.quality !== 'stable'
+        },
+        [NotebookSetting.outputWordWrap]: {
+            markdownDescription: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.outputWordWrap',
+                "Controls whether the lines in output should wrap."
+            )),
+            type: 'boolean',
+            tags: ['notebookLayout', 'notebookOutputLayout'],
+            default: false
+        },
+        [NotebookSetting.formatOnSave]: {
+            markdownDescription: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.formatOnSave',
+                "Format a notebook on save. A formatter must be available, the file must not be saved after delay, and the editor must not be shutting down."
+            )),
+            type: 'boolean',
+            tags: ['notebookLayout'],
+            default: false
+        },
+        [NotebookSetting.insertFinalNewline]: {
+            markdownDescription: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.insertFinalNewline',
+                "When enabled, insert a final new line into the end of code cells when saving a notebook."
+            )),
+            type: 'boolean',
+            tags: ['notebookLayout'],
+            default: false
+        },
+        [NotebookSetting.codeActionsOnSave]: {
+            markdownDescription: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.codeActionsOnSave',
+                'Run a series of Code Actions for a notebook on save. Code Actions must be specified, the file must not be saved after delay, and the editor must not be shutting down. Example: `"notebook.source.organizeImports": "explicit"`'
+            )),
+            type: 'object',
+            additionalProperties: {
+                type: ['string', 'boolean'],
+                enum: ['explicit', 'never', true, false],
+                enumDescriptions: [( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                    'explicit',
+                    'Triggers Code Actions only when explicitly saved.'
+                )), ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                    'never',
+                    'Never triggers Code Actions on save.'
+                )), ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                    'explicitBoolean',
+                    'Triggers Code Actions only when explicitly saved. This value will be deprecated in favor of "explicit".'
+                )), ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                    'neverBoolean',
+                    'Triggers Code Actions only when explicitly saved. This value will be deprecated in favor of "never".'
+                ))],
+            },
+            default: {}
+        },
+        [NotebookSetting.formatOnCellExecution]: {
+            markdownDescription: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.formatOnCellExecution',
+                "Format a notebook cell upon execution. A formatter must be available."
+            )),
+            type: 'boolean',
+            default: false
+        },
+        [NotebookSetting.confirmDeleteRunningCell]: {
+            markdownDescription: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.confirmDeleteRunningCell',
+                "Control whether a confirmation prompt is required to delete a running cell."
+            )),
+            type: 'boolean',
+            default: true
+        },
+        [NotebookSetting.findScope]: {
+            markdownDescription: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.findScope',
+                "Customize the Find Widget behavior for searching within notebook cells. When both markup source and markup preview are enabled, the Find Widget will search either the source code or preview based on the current state of the cell."
+            )),
+            type: 'object',
+            properties: {
+                markupSource: {
+                    type: 'boolean',
+                    default: true
+                },
+                markupPreview: {
+                    type: 'boolean',
+                    default: true
+                },
+                codeSource: {
+                    type: 'boolean',
+                    default: true
+                },
+                codeOutput: {
+                    type: 'boolean',
+                    default: true
+                }
+            },
+            default: {
+                markupSource: true,
+                markupPreview: true,
+                codeSource: true,
+                codeOutput: true
+            },
+            tags: ['notebookLayout']
+        },
+        [NotebookSetting.remoteSaving]: {
+            markdownDescription: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.remoteSaving',
+                "Enables the incremental saving of notebooks in Remote environment. When enabled, only the changes to the notebook are sent to the extension host, improving performance for large notebooks and slow network connections."
+            )),
+            type: 'boolean',
+            default: typeof product.quality === 'string' && product.quality !== 'stable'
+        },
+        [NotebookSetting.scrollToRevealCell]: {
+            markdownDescription: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.scrolling.revealNextCellOnExecute.description',
+                "How far to scroll when revealing the next cell upon running {0}.",
+                'notebook.cell.executeAndSelectBelow'
+            )),
+            type: 'string',
+            enum: ['fullCell', 'firstLine', 'none'],
+            markdownEnumDescriptions: [
+                ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                    'notebook.scrolling.revealNextCellOnExecute.fullCell.description',
+                    'Scroll to fully reveal the next cell.'
+                )),
+                ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                    'notebook.scrolling.revealNextCellOnExecute.firstLine.description',
+                    'Scroll to reveal the first line of the next cell.'
+                )),
+                ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                    'notebook.scrolling.revealNextCellOnExecute.none.description',
+                    'Do not scroll.'
+                )),
+            ],
+            default: 'fullCell'
+        },
+        [NotebookSetting.anchorToFocusedCell]: {
+            markdownDescription: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.scrolling.anchorToFocusedCell.description',
+                "Experimental. Keep the focused cell steady while surrounding cells change size."
+            )),
+            type: 'string',
+            enum: ['auto', 'on', 'off'],
+            markdownEnumDescriptions: [
+                ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                    'notebook.scrolling.anchorToFocusedCell.auto.description',
+                    "Anchor the viewport to the focused cell depending on context unless {0} is set to {1}.",
+                    'notebook.scrolling.revealCellBehavior',
+                    'none'
+                )),
+                ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                    'notebook.scrolling.anchorToFocusedCell.on.description',
+                    "Always anchor the viewport to the focused cell."
+                )),
+                ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                    'notebook.scrolling.anchorToFocusedCell.off.description',
+                    "The focused cell may shift around as cells resize."
+                ))
+            ],
+            default: 'auto'
+        },
+        [NotebookSetting.cellChat]: {
+            markdownDescription: ( nls.localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/notebook.contribution',
+                'notebook.cellChat',
+                "Enable experimental cell chat for notebooks."
+            )),
+            type: 'boolean',
+            default: false
+        }
+    }
+});
+
+export { NotebookContribution };