@codingame/monaco-vscode-notebook-service-override 4.5.0 → 4.5.2

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

@@ -4,81 +4,78 @@ import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/
 import { IAccessibleViewService } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibleView.service';
 import { getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
 
+const _moduleId = "vs/workbench/contrib/notebook/browser/notebookAccessibility";
 function getAccessibilityHelpText(accessor) {
     const keybindingService = accessor.get(IKeybindingService);
     const content = [];
     content.push(( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
-        'notebook.overview',
+        _moduleId,
+        0,
         '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',
+    content.push(descriptionForCommand('notebook.cell.edit', ( localizeWithPath(_moduleId, 1, 'The Edit Cell command ({0}) will focus on the cell input.')), ( localizeWithPath(
+        _moduleId,
+        2,
         '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',
+        _moduleId,
+        3,
         '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',
+        _moduleId,
+        4,
         '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',
+        _moduleId,
+        5,
         'The Focus Output command ({0}) will set focus in the cell\'s output.'
     )), ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
-        'notebook.cell.focusInOutputNoKb',
+        _moduleId,
+        6,
         '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',
+        _moduleId,
+        7,
         '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',
+        _moduleId,
+        8,
         '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',
+        _moduleId,
+        9,
         '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',
+        _moduleId,
+        10,
         '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',
+        _moduleId,
+        11,
         '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',
+        _moduleId,
+        12,
         'The Execute Cell command ({0}) executes the cell that currently has focus.'
     )), ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
-        'notebook.cell.executeAndFocusContainerNoKb',
+        _moduleId,
+        13,
         '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',
+        _moduleId,
+        14,
         'The Insert Cell Above/Below commands will create new empty code cells'
     )));
     content.push(( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
-        'notebook.changeCellType',
+        _moduleId,
+        15,
         'The Change Cell to Code/Markdown commands are used to switch between cell types.'
     )));
     return content.join('\n\n');
@@ -114,7 +111,7 @@ function showAccessibleOutput(accessibleViewService, editorService) {
     }
     const viewCell = notebookViewModel.viewCells[selections[0].start];
     let outputContent = '';
-    const decoder = ( new TextDecoder());
+    const decoder = ( (new TextDecoder()));
     for (let i = 0; i < viewCell.outputsViewModels.length; i++) {
         const outputViewModel = viewCell.outputsViewModels[i];
         const outputTextModel = viewCell.model.outputs[i];

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

@@ -6,13 +6,14 @@ import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/d
 import { Extensions } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionFeatures';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
 
-const NotebookEditorContribution = ( Object.freeze({
+const _moduleId = "vs/workbench/contrib/notebook/browser/notebookExtensionPoint";
+const NotebookEditorContribution = ( (Object.freeze({
     type: 'type',
     displayName: 'displayName',
     selector: 'selector',
     priority: 'priority',
-}));
-const NotebookRendererContribution = ( Object.freeze({
+})));
+const NotebookRendererContribution = ( (Object.freeze({
     id: 'id',
     displayName: 'displayName',
     mimeTypes: 'mimeTypes',
@@ -20,18 +21,14 @@ const NotebookRendererContribution = ( Object.freeze({
     hardDependencies: 'dependencies',
     optionalDependencies: 'optionalDependencies',
     requiresMessaging: 'requiresMessaging',
-}));
-const NotebookPreloadContribution = ( Object.freeze({
+})));
+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.'
-    )),
+    description: ( localizeWithPath(_moduleId, 0, 'Contributes notebook document provider.')),
     type: 'array',
     defaultSnippets: [{ body: [{ type: '', displayName: '', 'selector': [{ 'filenamePattern': '' }] }] }],
     items: {
@@ -44,45 +41,25 @@ const notebookProviderContribution = {
         properties: {
             [NotebookEditorContribution.type]: {
                 type: 'string',
-                description: ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                    'contributes.notebook.provider.viewType',
-                    'Type of the notebook.'
-                )),
+                description: ( localizeWithPath(_moduleId, 1, '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.'
-                )),
+                description: ( localizeWithPath(_moduleId, 2, '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.'
-                )),
+                description: ( localizeWithPath(_moduleId, 3, '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.'
-                            )),
+                            description: ( localizeWithPath(_moduleId, 4, '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.'
-                            ))
+                            description: ( localizeWithPath(_moduleId, 5, 'Glob that the notebook is disabled for.'))
                         }
                     }
                 }
@@ -90,8 +67,8 @@ const notebookProviderContribution = {
             [NotebookEditorContribution.priority]: {
                 type: 'string',
                 markdownDeprecationMessage: ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                    'contributes.priority',
+                    _moduleId,
+                    6,
                     '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: [
@@ -100,13 +77,13 @@ const notebookProviderContribution = {
                 ],
                 markdownEnumDescriptions: [
                     ( localizeWithPath(
-                        'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                        'contributes.priority.default',
+                        _moduleId,
+                        7,
                         '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',
+                        _moduleId,
+                        8,
                         '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.'
                     )),
                 ],
@@ -115,13 +92,9 @@ const notebookProviderContribution = {
         }
     }
 };
-const defaultRendererSnippet = ( Object.freeze({ id: '', displayName: '', mimeTypes: [''], entrypoint: '' }));
+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.'
-    )),
+    description: ( localizeWithPath(_moduleId, 9, 'Contributes notebook output renderer provider.')),
     type: 'array',
     defaultSnippets: [{ body: [defaultRendererSnippet] }],
     items: {
@@ -136,27 +109,19 @@ const notebookRendererContribution = {
                 properties: {
                     [NotebookRendererContribution.id]: {
                         type: 'string',
-                        description: ( localizeWithPath(
-                            'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                            'contributes.notebook.renderer.viewType',
-                            'Unique identifier of the notebook output renderer.'
-                        )),
+                        description: ( localizeWithPath(_moduleId, 10, '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.'
-                        )),
+                        description: ( localizeWithPath(_moduleId, 11, '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',
+                            _moduleId,
+                            12,
                             'List of kernel dependencies the renderer requires. If any of the dependencies are present in the `NotebookKernel.preloads`, the renderer can be used.'
                         )),
                     },
@@ -165,8 +130,8 @@ const notebookRendererContribution = {
                         uniqueItems: true,
                         items: { type: 'string' },
                         markdownDescription: ( localizeWithPath(
-                            'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                            'contributes.notebook.renderer.optionalDependencies',
+                            _moduleId,
+                            13,
                             '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.'
                         )),
                     },
@@ -179,24 +144,20 @@ const notebookRendererContribution = {
                         ],
                         enumDescriptions: [
                             ( localizeWithPath(
-                                'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                                'contributes.notebook.renderer.requiresMessaging.always',
+                                _moduleId,
+                                14,
                                 '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',
+                                _moduleId,
+                                15,
                                 '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.'
-                            )),
+                            ( localizeWithPath(_moduleId, 16, 'The renderer does not require messaging.')),
                         ],
                         description: ( localizeWithPath(
-                            'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                            'contributes.notebook.renderer.requiresMessaging',
+                            _moduleId,
+                            17,
                             '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.'
                         )),
                     },
@@ -212,21 +173,13 @@ const notebookRendererContribution = {
                         properties: {
                             [NotebookRendererContribution.mimeTypes]: {
                                 type: 'array',
-                                description: ( localizeWithPath(
-                                    'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                                    'contributes.notebook.selector',
-                                    'Set of globs that the notebook is for.'
-                                )),
+                                description: ( localizeWithPath(_moduleId, 18, '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.'
-                                )),
+                                description: ( localizeWithPath(_moduleId, 19, 'File to load in the webview to render the extension.')),
                                 type: 'string',
                             },
                         }
@@ -237,29 +190,17 @@ const notebookRendererContribution = {
                         ],
                         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.'
-                                )),
+                                description: ( localizeWithPath(_moduleId, 19, '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.'
-                                        )),
+                                        description: ( localizeWithPath(_moduleId, 20, '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.'
-                                        )),
+                                        description: ( localizeWithPath(_moduleId, 19, 'File to load in the webview to render the extension.')),
                                     },
                                 }
                             },
@@ -271,11 +212,7 @@ const notebookRendererContribution = {
     }
 };
 const notebookPreloadContribution = {
-    description: ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-        'contributes.preload.provider',
-        'Contributes notebook preloads.'
-    )),
+    description: ( localizeWithPath(_moduleId, 21, 'Contributes notebook preloads.')),
     type: 'array',
     defaultSnippets: [{ body: [{ type: '', entrypoint: '' }] }],
     items: {
@@ -287,26 +224,18 @@ const notebookPreloadContribution = {
         properties: {
             [NotebookPreloadContribution.type]: {
                 type: 'string',
-                description: ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-                    'contributes.preload.provider.viewType',
-                    'Type of the notebook.'
-                )),
+                description: ( localizeWithPath(_moduleId, 22, '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.'
-                )),
+                description: ( localizeWithPath(_moduleId, 23, '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',
+                    _moduleId,
+                    24,
                     'Paths to additional resources that should be allowed in the webview.'
                 )),
             },
@@ -353,25 +282,17 @@ class NotebooksDataRenderer extends Disposable {
             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"
-            )),
+            ( localizeWithPath(_moduleId, 25, "ID")),
+            ( localizeWithPath(_moduleId, 26, "Name")),
         ];
-        const rows = ( contrib
+        const rows = ( (contrib
             .sort((a, b) => a.type.localeCompare(b.type))
             .map(notebook => {
             return [
                 notebook.type,
                 notebook.displayName
             ];
-        }));
+        })));
         return {
             data: {
                 headers,
@@ -395,25 +316,17 @@ class NotebookRenderersDataRenderer extends Disposable {
             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"
-            )),
+            ( localizeWithPath(_moduleId, 27, "Name")),
+            ( localizeWithPath(_moduleId, 28, "Mimetypes")),
         ];
-        const rows = ( contrib
+        const rows = ( (contrib
             .sort((a, b) => a.displayName.localeCompare(b.displayName))
             .map(notebookRenderer => {
             return [
                 notebookRenderer.displayName,
                 notebookRenderer.mimeTypes.join(',')
             ];
-        }));
+        })));
         return {
             data: {
                 headers,
@@ -423,29 +336,21 @@ class NotebookRenderersDataRenderer extends Disposable {
         };
     }
 }
-( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
+( (Registry.as(Extensions.ExtensionFeaturesRegistry))).registerExtensionFeature({
     id: 'notebooks',
-    label: ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-        'notebooks',
-        "Notebooks"
-    )),
+    label: ( localizeWithPath(_moduleId, 29, "Notebooks")),
     access: {
         canToggle: false
     },
-    renderer: ( new SyncDescriptor(NotebooksDataRenderer)),
+    renderer: ( (new SyncDescriptor(NotebooksDataRenderer))),
 });
-( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
+( (Registry.as(Extensions.ExtensionFeaturesRegistry))).registerExtensionFeature({
     id: 'notebookRenderer',
-    label: ( localizeWithPath(
-        'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
-        'notebookRenderer',
-        "Notebook Renderers"
-    )),
+    label: ( localizeWithPath(_moduleId, 30, "Notebook Renderers")),
     access: {
         canToggle: false
     },
-    renderer: ( new SyncDescriptor(NotebookRenderersDataRenderer)),
+    renderer: ( (new SyncDescriptor(NotebookRenderersDataRenderer))),
 });
 
 export { notebookPreloadExtensionPoint, notebookRendererExtensionPoint, notebooksExtensionPoint };

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

@@ -108,7 +108,7 @@ let NotebookEditorWidgetService = class NotebookEditorWidgetService {
         }
         const widget = this._borrowableEditors.get(sourceID)?.get(input.resource);
         if (!widget) {
-            throw new Error('no widget at source group');
+            throw ( new Error('no widget at source group'));
         }
         this._borrowableEditors.get(sourceID)?.delete(input.resource);
         let targetMap = this._borrowableEditors.get(targetID);

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

@@ -9,6 +9,7 @@ import { CellKind, NotebookCellExecutionState } from 'vscode/vscode/vs/workbench
 import { INotebookExecutionStateService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService.service';
 import { INotebookKernelService, INotebookKernelHistoryService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService.service';
 
+const _moduleId = "vs/workbench/contrib/notebook/browser/services/notebookExecutionServiceImpl";
 let NotebookExecutionService = class NotebookExecutionService {
     constructor(_commandService, _notebookKernelService, _notebookKernelHistoryService, _workspaceTrustRequestService, _logService, _notebookExecutionStateService) {
         this._commandService = _commandService;
@@ -17,7 +18,7 @@ let NotebookExecutionService = class NotebookExecutionService {
         this._workspaceTrustRequestService = _workspaceTrustRequestService;
         this._logService = _logService;
         this._notebookExecutionStateService = _notebookExecutionStateService;
-        this.cellExecutionParticipants = ( new Set());
+        this.cellExecutionParticipants = ( (new Set()));
     }
     async executeNotebookCells(notebook, cells, contextKeyService) {
         const cellsArr = Array.from(cells)
@@ -25,10 +26,10 @@ let NotebookExecutionService = class NotebookExecutionService {
         if (!cellsArr.length) {
             return;
         }
-        this._logService.debug(`NotebookExecutionService#executeNotebookCells ${JSON.stringify(( cellsArr.map(c => c.handle)))}`);
+        this._logService.debug(`NotebookExecutionService#executeNotebookCells ${JSON.stringify(( (cellsArr.map(c => c.handle))))}`);
         const message = ( localizeWithPath(
-            'vs/workbench/contrib/notebook/browser/services/notebookExecutionServiceImpl',
-            'notebookRunTrust',
+            _moduleId,
+            0,
             "Executing a notebook cell will run code from this workspace."
         ));
         const trust = await this._workspaceTrustRequestService.requestWorkspaceTrust({ message });
@@ -61,10 +62,10 @@ let NotebookExecutionService = class NotebookExecutionService {
         if (validCellExecutions.length > 0) {
             await this.runExecutionParticipants(validCellExecutions);
             this._notebookKernelService.selectKernelForNotebook(kernel, notebook);
-            await kernel.executeNotebookCellsRequest(notebook.uri, ( validCellExecutions.map(c => c.cellHandle)));
+            await kernel.executeNotebookCellsRequest(notebook.uri, ( (validCellExecutions.map(c => c.cellHandle))));
             const unconfirmed = validCellExecutions.filter(exe => exe.state === NotebookCellExecutionState.Unconfirmed);
             if (unconfirmed.length) {
-                this._logService.debug(`NotebookExecutionService#executeNotebookCells completing unconfirmed executions ${JSON.stringify(( unconfirmed.map(exe => exe.cellHandle)))}`);
+                this._logService.debug(`NotebookExecutionService#executeNotebookCells completing unconfirmed executions ${JSON.stringify(( (unconfirmed.map(exe => exe.cellHandle))))}`);
                 unconfirmed.forEach(exe => exe.complete({}));
             }
         }
@@ -94,13 +95,13 @@ let NotebookExecutionService = class NotebookExecutionService {
         this._activeProxyKernelExecutionToken?.dispose(true);
     }
 };
-NotebookExecutionService = ( __decorate([
-    ( __param(0, ICommandService)),
-    ( __param(1, INotebookKernelService)),
-    ( __param(2, INotebookKernelHistoryService)),
-    ( __param(3, IWorkspaceTrustRequestService)),
-    ( __param(4, ILogService)),
-    ( __param(5, INotebookExecutionStateService))
-], NotebookExecutionService));
+NotebookExecutionService = ( (__decorate([
+    ( (__param(0, ICommandService))),
+    ( (__param(1, INotebookKernelService))),
+    ( (__param(2, INotebookKernelHistoryService))),
+    ( (__param(3, IWorkspaceTrustRequestService))),
+    ( (__param(4, ILogService))),
+    ( (__param(5, INotebookExecutionStateService)))
+], NotebookExecutionService)));
 
 export { NotebookExecutionService };

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

@@ -51,7 +51,7 @@ let NotebookExecutionStateService = class NotebookExecutionStateService extends
     getCellExecution(cellUri) {
         const parsed = CellUri.parse(cellUri);
         if (!parsed) {
-            throw new Error(`Not a cell URI: ${cellUri}`);
+            throw ( new Error(`Not a cell URI: ${cellUri}`));
         }
         const exeMap = this._executions.get(parsed.notebook);
         if (exeMap) {
@@ -119,7 +119,7 @@ let NotebookExecutionStateService = class NotebookExecutionStateService extends
     createCellExecution(notebookUri, cellHandle) {
         const notebook = this._notebookService.getNotebookTextModel(notebookUri);
         if (!notebook) {
-            throw new Error(`Notebook not found: ${notebookUri.toString()}`);
+            throw ( new Error(`Notebook not found: ${( notebookUri.toString())}`));
         }
         let notebookExecutionMap = this._executions.get(notebookUri);
         if (!notebookExecutionMap) {
@@ -140,7 +140,7 @@ let NotebookExecutionStateService = class NotebookExecutionStateService extends
     createExecution(notebookUri) {
         const notebook = this._notebookService.getNotebookTextModel(notebookUri);
         if (!notebook) {
-            throw new Error(`Notebook not found: ${notebookUri.toString()}`);
+            throw ( new Error(`Notebook not found: ${( notebookUri.toString())}`));
         }
         if (!( this._notebookListeners.has(notebookUri))) {
             const listeners = this._instantiationService.createInstance(NotebookExecutionListeners, notebookUri);
@@ -276,7 +276,7 @@ let NotebookExecutionListeners = class NotebookExecutionListeners extends Dispos
         this._logService.debug(`NotebookExecution#ctor ${( notebook.toString())}`);
         const notebookModel = this._notebookService.getNotebookTextModel(notebook);
         if (!notebookModel) {
-            throw new Error('Notebook not found: ' + notebook);
+            throw ( new Error('Notebook not found: ' + notebook));
         }
         this._notebookModel = notebookModel;
         this._register(this._notebookModel.onWillAddRemoveCells(e => this.onWillAddRemoveCells(e)));
@@ -362,7 +362,7 @@ function updateToEdit(update, cellHandle) {
             internalMetadata: newInternalMetadata
         };
     }
-    throw new Error('Unknown cell update type');
+    throw ( new Error('Unknown cell update type'));
 }
 let CellExecution = class CellExecution extends Disposable {
     get state() {