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

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

@@ -35,6 +35,7 @@ import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/commo
 import { INotebookDocumentService } from 'vscode/vscode/vs/workbench/services/notebook/common/notebookDocumentService.service';
 
 var NotebookProviderInfoStore_1, NotebookService_1;
+const _moduleId = "vs/workbench/contrib/notebook/browser/services/notebookServiceImpl";
 let NotebookProviderInfoStore = class NotebookProviderInfoStore extends Disposable {
     static { NotebookProviderInfoStore_1 = this; }
     static { this.CUSTOM_EDITORS_STORAGE_ID = 'notebookEditors'; }
@@ -49,13 +50,13 @@ let NotebookProviderInfoStore = class NotebookProviderInfoStore extends Disposab
         this._notebookEditorModelResolverService = _notebookEditorModelResolverService;
         this.uriIdentService = uriIdentService;
         this._handled = false;
-        this._contributedEditors = ( new Map());
-        this._contributedEditorDisposables = this._register(( new DisposableStore()));
-        this._memento = ( new Memento(NotebookProviderInfoStore_1.CUSTOM_EDITORS_STORAGE_ID, storageService));
+        this._contributedEditors = ( (new Map()));
+        this._contributedEditorDisposables = this._register(( (new DisposableStore())));
+        this._memento = ( (new Memento(NotebookProviderInfoStore_1.CUSTOM_EDITORS_STORAGE_ID, storageService)));
         const mementoObject = this._memento.getMemento(0 , 1 );
         this._editorResolverService.bufferChangeEvents(() => {
             for (const info of (mementoObject[NotebookProviderInfoStore_1.CUSTOM_EDITORS_ENTRY_ID] || [])) {
-                this.add(( new NotebookProviderInfo(info)));
+                this.add(( (new NotebookProviderInfo(info))));
             }
         });
         this._register(extensionService.onDidRegisterExtensions(() => {
@@ -73,9 +74,9 @@ let NotebookProviderInfoStore = class NotebookProviderInfoStore extends Disposab
     }
     _setupHandler(extensions) {
         this._handled = true;
-        const builtins = [...( this._contributedEditors.values())].filter(info => !info.extension);
+        const builtins = [...( (this._contributedEditors.values()))].filter(info => !info.extension);
         this._clear();
-        const builtinProvidersFromCache = ( new Map());
+        const builtinProvidersFromCache = ( (new Map()));
         builtins.forEach(builtin => {
             builtinProvidersFromCache.set(builtin.id, this.add(builtin));
         });
@@ -95,7 +96,7 @@ let NotebookProviderInfoStore = class NotebookProviderInfoStore extends Disposab
                         continue;
                     }
                 }
-                this.add(( new NotebookProviderInfo({
+                this.add(( (new NotebookProviderInfo({
                     extension: extension.description.identifier,
                     id: notebookContribution.type,
                     displayName: notebookContribution.displayName,
@@ -103,11 +104,11 @@ let NotebookProviderInfoStore = class NotebookProviderInfoStore extends Disposab
                     priority: this._convertPriority(notebookContribution.priority),
                     providerDisplayName: extension.description.displayName ?? extension.description.identifier.value,
                     exclusive: false
-                })));
+                }))));
             }
         }
         const mementoObject = this._memento.getMemento(0 , 1 );
-        mementoObject[NotebookProviderInfoStore_1.CUSTOM_EDITORS_ENTRY_ID] = Array.from(( this._contributedEditors.values()));
+        mementoObject[NotebookProviderInfoStore_1.CUSTOM_EDITORS_ENTRY_ID] = Array.from(( (this._contributedEditors.values())));
         this._memento.saveMemento();
     }
     clearEditorCache() {
@@ -125,7 +126,7 @@ let NotebookProviderInfoStore = class NotebookProviderInfoStore extends Disposab
         return RegisteredEditorPriority.option;
     }
     _registerContributionPoint(notebookProviderInfo) {
-        const disposables = ( new DisposableStore());
+        const disposables = ( (new DisposableStore()));
         for (const selector of notebookProviderInfo.selectors) {
             const globPattern = selector.include || selector;
             const notebookEditorInfo = {
@@ -214,8 +215,8 @@ let NotebookProviderInfoStore = class NotebookProviderInfoStore extends Disposab
         return this._contributedEditors.get(viewType);
     }
     add(info) {
-        if (( this._contributedEditors.has(info.id))) {
-            throw new Error(`notebook type '${info.id}' ALREADY EXISTS`);
+        if (( (this._contributedEditors.has(info.id)))) {
+            throw ( (new Error(`notebook type '${info.id}' ALREADY EXISTS`)));
         }
         this._contributedEditors.set(info.id, info);
         let editorRegistration;
@@ -224,11 +225,11 @@ let NotebookProviderInfoStore = class NotebookProviderInfoStore extends Disposab
             this._contributedEditorDisposables.add(editorRegistration);
         }
         const mementoObject = this._memento.getMemento(0 , 1 );
-        mementoObject[NotebookProviderInfoStore_1.CUSTOM_EDITORS_ENTRY_ID] = Array.from(( this._contributedEditors.values()));
+        mementoObject[NotebookProviderInfoStore_1.CUSTOM_EDITORS_ENTRY_ID] = Array.from(( (this._contributedEditors.values())));
         this._memento.saveMemento();
         return this._register(toDisposable(() => {
             const mementoObject = this._memento.getMemento(0 , 1 );
-            mementoObject[NotebookProviderInfoStore_1.CUSTOM_EDITORS_ENTRY_ID] = Array.from(( this._contributedEditors.values()));
+            mementoObject[NotebookProviderInfoStore_1.CUSTOM_EDITORS_ENTRY_ID] = Array.from(( (this._contributedEditors.values())));
             this._memento.saveMemento();
             editorRegistration?.dispose();
             this._contributedEditors.delete(info.id);
@@ -236,38 +237,40 @@ let NotebookProviderInfoStore = class NotebookProviderInfoStore extends Disposab
     }
     getContributedNotebook(resource) {
         const result = [];
-        for (const info of ( this._contributedEditors.values())) {
+        for (const info of ( (this._contributedEditors.values()))) {
             if (info.matches(resource)) {
                 result.push(info);
             }
         }
         if (result.length === 0 && resource.scheme === Schemas.untitled) {
-            return Array.from(( this._contributedEditors.values()));
+            return Array.from(( (this._contributedEditors.values())));
         }
         return result;
     }
     [Symbol.iterator]() {
-        return ( this._contributedEditors.values());
+        return (
+             (this._contributedEditors.values())
+        );
     }
 };
-NotebookProviderInfoStore = NotebookProviderInfoStore_1 = ( __decorate([
-    ( __param(0, IStorageService)),
-    ( __param(1, IExtensionService)),
-    ( __param(2, IEditorResolverService)),
-    ( __param(3, IConfigurationService)),
-    ( __param(4, IAccessibilityService)),
-    ( __param(5, IInstantiationService)),
-    ( __param(6, IFileService)),
-    ( __param(7, INotebookEditorModelResolverService)),
-    ( __param(8, IUriIdentityService))
-], NotebookProviderInfoStore));
+NotebookProviderInfoStore = NotebookProviderInfoStore_1 = ( (__decorate([
+    ( (__param(0, IStorageService))),
+    ( (__param(1, IExtensionService))),
+    ( (__param(2, IEditorResolverService))),
+    ( (__param(3, IConfigurationService))),
+    ( (__param(4, IAccessibilityService))),
+    ( (__param(5, IInstantiationService))),
+    ( (__param(6, IFileService))),
+    ( (__param(7, INotebookEditorModelResolverService))),
+    ( (__param(8, IUriIdentityService)))
+], NotebookProviderInfoStore)));
 let NotebookOutputRendererInfoStore = class NotebookOutputRendererInfoStore {
     constructor(storageService) {
-        this.contributedRenderers = ( new Map());
-        this.preferredMimetype = ( new Lazy(
+        this.contributedRenderers = ( (new Map()));
+        this.preferredMimetype = ( (new Lazy(
             () => this.preferredMimetypeMemento.getMemento(1 , 1 )
-        ));
-        this.preferredMimetypeMemento = ( new Memento('workbench.editor.notebook.preferredRenderer2', storageService));
+        )));
+        this.preferredMimetypeMemento = ( (new Memento('workbench.editor.notebook.preferredRenderer2', storageService)));
     }
     clear() {
         this.contributedRenderers.clear();
@@ -276,10 +279,10 @@ let NotebookOutputRendererInfoStore = class NotebookOutputRendererInfoStore {
         return this.contributedRenderers.get(rendererId);
     }
     getAll() {
-        return Array.from(( this.contributedRenderers.values()));
+        return Array.from(( (this.contributedRenderers.values())));
     }
     add(info) {
-        if (( this.contributedRenderers.has(info.id))) {
+        if (( (this.contributedRenderers.has(info.id)))) {
             return;
         }
         this.contributedRenderers.set(info.id, info);
@@ -299,7 +302,7 @@ let NotebookOutputRendererInfoStore = class NotebookOutputRendererInfoStore {
         const preferred = notebookProviderInfo && this.preferredMimetype.value[notebookProviderInfo.id]?.[mimeType];
         const notebookExtId = notebookProviderInfo?.extension?.value;
         const notebookId = notebookProviderInfo?.id;
-        const renderers = ( Array.from(( this.contributedRenderers.values()))
+        const renderers = ( (Array.from(( (this.contributedRenderers.values())))
             .map(renderer => {
             const ownScore = kernelProvides === undefined
                 ? renderer.matchesWithoutKernel(mimeType)
@@ -317,21 +320,23 @@ let NotebookOutputRendererInfoStore = class NotebookOutputRendererInfoStore {
                 ordered: { mimeType, rendererId: renderer.id, isTrusted: true },
                 score: reuseScore | ownScore,
             };
-        })).filter(isDefined);
+        }))).filter(isDefined);
         if (renderers.length === 0) {
             return [{ mimeType, rendererId: RENDERER_NOT_AVAILABLE, isTrusted: true }];
         }
-        return ( renderers.sort((a, b) => a.score - b.score).map(r => r.ordered));
+        return (
+             (renderers.sort((a, b) => a.score - b.score).map(r => r.ordered))
+        );
     }
 };
-NotebookOutputRendererInfoStore = ( __decorate([
-    ( __param(0, IStorageService))
-], NotebookOutputRendererInfoStore));
+NotebookOutputRendererInfoStore = ( (__decorate([
+    ( (__param(0, IStorageService)))
+], NotebookOutputRendererInfoStore)));
 class ModelData {
     get uri() { return this.model.uri; }
     constructor(model, onWillDispose) {
         this.model = model;
-        this._modelEventListeners = ( new DisposableStore());
+        this._modelEventListeners = ( (new DisposableStore()));
         this._modelEventListeners.add(model.onWillDispose(() => onWillDispose(model)));
     }
     getCellIndex(cellUri) {
@@ -358,26 +363,26 @@ let NotebookService = class NotebookService extends Disposable {
         this._instantiationService = _instantiationService;
         this._storageService = _storageService;
         this._notebookDocumentService = _notebookDocumentService;
-        this._notebookProviders = ( new Map());
+        this._notebookProviders = ( (new Map()));
         this._notebookProviderInfoStore = undefined;
         this._notebookRenderersInfoStore = this._instantiationService.createInstance(NotebookOutputRendererInfoStore);
-        this._onDidChangeOutputRenderers = this._register(( new Emitter()));
+        this._onDidChangeOutputRenderers = this._register(( (new Emitter())));
         this.onDidChangeOutputRenderers = this._onDidChangeOutputRenderers.event;
-        this._notebookStaticPreloadInfoStore = ( new Set());
-        this._models = ( new ResourceMap());
-        this._onWillAddNotebookDocument = this._register(( new Emitter()));
-        this._onDidAddNotebookDocument = this._register(( new Emitter()));
-        this._onWillRemoveNotebookDocument = this._register(( new Emitter()));
-        this._onDidRemoveNotebookDocument = this._register(( new Emitter()));
+        this._notebookStaticPreloadInfoStore = ( (new Set()));
+        this._models = ( (new ResourceMap()));
+        this._onWillAddNotebookDocument = this._register(( (new Emitter())));
+        this._onDidAddNotebookDocument = this._register(( (new Emitter())));
+        this._onWillRemoveNotebookDocument = this._register(( (new Emitter())));
+        this._onDidRemoveNotebookDocument = this._register(( (new Emitter())));
         this.onWillAddNotebookDocument = this._onWillAddNotebookDocument.event;
         this.onDidAddNotebookDocument = this._onDidAddNotebookDocument.event;
         this.onDidRemoveNotebookDocument = this._onDidRemoveNotebookDocument.event;
         this.onWillRemoveNotebookDocument = this._onWillRemoveNotebookDocument.event;
-        this._onAddViewType = this._register(( new Emitter()));
+        this._onAddViewType = this._register(( (new Emitter())));
         this.onAddViewType = this._onAddViewType.event;
-        this._onWillRemoveViewType = this._register(( new Emitter()));
+        this._onWillRemoveViewType = this._register(( (new Emitter())));
         this.onWillRemoveViewType = this._onWillRemoveViewType.event;
-        this._onDidChangeEditorTypes = this._register(( new Emitter()));
+        this._onDidChangeEditorTypes = this._register(( (new Emitter())));
         this.onDidChangeEditorTypes = this._onDidChangeEditorTypes.event;
         this._lastClipboardIsCopy = true;
         notebookRendererExtensionPoint.setHandler((renderers) => {
@@ -393,7 +398,7 @@ let NotebookService = class NotebookService extends Disposable {
                         extension.collector.error(`Notebook renderer does not specify id-property`);
                         continue;
                     }
-                    this._notebookRenderersInfoStore.add(( new NotebookOutputRendererInfo({
+                    this._notebookRenderersInfoStore.add(( (new NotebookOutputRendererInfo({
                         id,
                         extension: extension.description,
                         entrypoint: notebookContribution.entrypoint,
@@ -402,7 +407,7 @@ let NotebookService = class NotebookService extends Disposable {
                         dependencies: notebookContribution.dependencies,
                         optionalDependencies: notebookContribution.optionalDependencies,
                         requiresMessaging: notebookContribution.requiresMessaging,
-                    })));
+                    }))));
                 }
             }
             this._onDidChangeOutputRenderers.fire();
@@ -423,22 +428,22 @@ let NotebookService = class NotebookService extends Disposable {
                         extension.collector.error(`Notebook preload does not specify type-property`);
                         continue;
                     }
-                    this._notebookStaticPreloadInfoStore.add(( new NotebookStaticPreloadInfo({
+                    this._notebookStaticPreloadInfoStore.add(( (new NotebookStaticPreloadInfo({
                         type,
                         extension: extension.description,
                         entrypoint: notebookContribution.entrypoint,
                         localResourceRoots: notebookContribution.localResourceRoots ?? [],
-                    })));
+                    }))));
                 }
             }
         });
         const updateOrder = () => {
-            this._displayOrder = ( new MimeTypeDisplayOrder(
+            this._displayOrder = ( (new MimeTypeDisplayOrder(
                 this._configurationService.getValue(NotebookSetting.displayOrder) || [],
                 this._accessibilityService.isScreenReaderOptimized()
                     ? ACCESSIBLE_NOTEBOOK_DISPLAY_ORDER
                     : NOTEBOOK_DISPLAY_ORDER
-            ));
+            )));
         };
         updateOrder();
         this._register(this._configurationService.onDidChangeConfiguration(e => {
@@ -449,15 +454,17 @@ let NotebookService = class NotebookService extends Disposable {
         this._register(this._accessibilityService.onDidChangeScreenReaderOptimized(() => {
             updateOrder();
         }));
-        this._memento = ( new Memento(NotebookService_1._storageNotebookViewTypeProvider, this._storageService));
+        this._memento = ( (new Memento(NotebookService_1._storageNotebookViewTypeProvider, this._storageService)));
         this._viewTypeCache = this._memento.getMemento(1 , 1 );
     }
     getEditorTypes() {
-        return ( [...this.notebookProviderInfoStore].map(info => ({
-            id: info.id,
-            displayName: info.displayName,
-            providerDisplayName: info.providerDisplayName
-        })));
+        return (
+             ([...this.notebookProviderInfoStore].map(info => ({
+                id: info.id,
+                displayName: info.displayName,
+                providerDisplayName: info.providerDisplayName
+            })))
+        );
     }
     clearEditorCache() {
         this.notebookProviderInfoStore.clearEditorCache();
@@ -467,15 +474,17 @@ let NotebookService = class NotebookService extends Disposable {
         this._extensionService.activateByEvent(`onNotebook:*`);
     }
     async canResolve(viewType) {
-        if (( this._notebookProviders.has(viewType))) {
+        if (( (this._notebookProviders.has(viewType)))) {
             return true;
         }
         await this._extensionService.whenInstalledExtensionsRegistered();
         await this._extensionService.activateByEvent(`onNotebookSerializer:${viewType}`);
-        return ( this._notebookProviders.has(viewType));
+        return (
+             (this._notebookProviders.has(viewType))
+        );
     }
     registerContributedNotebookType(viewType, data) {
-        const info = ( new NotebookProviderInfo({
+        const info = ( (new NotebookProviderInfo({
             extension: data.extension,
             id: viewType,
             displayName: data.displayName,
@@ -483,7 +492,7 @@ let NotebookService = class NotebookService extends Disposable {
             exclusive: data.exclusive,
             priority: RegisteredEditorPriority.default,
             selectors: []
-        }));
+        })));
         info.update({ selectors: data.filenamePattern });
         const reg = this.notebookProviderInfoStore.add(info);
         this._onDidChangeEditorTypes.fire();
@@ -493,8 +502,8 @@ let NotebookService = class NotebookService extends Disposable {
         });
     }
     _registerProviderData(viewType, data) {
-        if (( this._notebookProviders.has(viewType))) {
-            throw new Error(`notebook provider for viewtype '${viewType}' already exists`);
+        if (( (this._notebookProviders.has(viewType)))) {
+            throw ( (new Error(`notebook provider for viewtype '${viewType}' already exists`)));
         }
         this._notebookProviders.set(viewType, data);
         this._onAddViewType.fire(viewType);
@@ -507,7 +516,7 @@ let NotebookService = class NotebookService extends Disposable {
         this.notebookProviderInfoStore.get(viewType)?.update({ options: serializer.options });
         this._viewTypeCache[viewType] = extensionData.id.value;
         this._persistMementos();
-        return this._registerProviderData(viewType, ( new SimpleNotebookProviderInfo(viewType, serializer, extensionData)));
+        return this._registerProviderData(viewType, ( (new SimpleNotebookProviderInfo(viewType, serializer, extensionData))));
     }
     async withNotebookDataProvider(viewType) {
         const selected = this.notebookProviderInfoStore.get(viewType);
@@ -515,12 +524,7 @@ let NotebookService = class NotebookService extends Disposable {
             const knownProvider = this.getViewTypeProvider(viewType);
             const actions = knownProvider ? [
                 toAction({
-                    id: 'workbench.notebook.action.installMissingViewType', label: ( localizeWithPath(
-                    'vs/workbench/contrib/notebook/browser/services/notebookServiceImpl',
-                    'notebookOpenInstallMissingViewType',
-                    "Install extension for '{0}'",
-                    viewType
-                )), run: async () => {
+                    id: 'workbench.notebook.action.installMissingViewType', label: ( localizeWithPath(_moduleId, 0, "Install extension for '{0}'", viewType)), run: async () => {
                         await this._instantiationService.createInstance(InstallRecommendedExtensionAction, knownProvider).run();
                     }
                 })
@@ -530,7 +534,7 @@ let NotebookService = class NotebookService extends Disposable {
         await this.canResolve(selected.id);
         const result = this._notebookProviders.get(selected.id);
         if (!result) {
-            throw new Error(`NO provider registered for view type: '${selected.id}'`);
+            throw ( (new Error(`NO provider registered for view type: '${selected.id}'`)));
         }
         return result;
     }
@@ -564,11 +568,11 @@ let NotebookService = class NotebookService extends Disposable {
         }
     }
     createNotebookTextModel(viewType, uri, data, transientOptions) {
-        if (( this._models.has(uri))) {
-            throw new Error(`notebook for ${uri} already exists`);
+        if (( (this._models.has(uri)))) {
+            throw ( (new Error(`notebook for ${uri} already exists`)));
         }
         const notebookModel = this._instantiationService.createInstance(NotebookTextModel, viewType, uri, data.cells, data.metadata, transientOptions);
-        const modelData = ( new ModelData(notebookModel, this._onWillDisposeDocument.bind(this)));
+        const modelData = ( (new ModelData(notebookModel, this._onWillDisposeDocument.bind(this))));
         this._models.set(uri, modelData);
         this._notebookDocumentService.addNotebookDocument(modelData);
         this._onWillAddNotebookDocument.fire(notebookModel);
@@ -580,10 +584,14 @@ let NotebookService = class NotebookService extends Disposable {
         return this._models.get(uri)?.model;
     }
     getNotebookTextModels() {
-        return ( Iterable.map(( this._models.values()), data => data.model));
+        return (
+             (Iterable.map( (this._models.values()), data => data.model))
+        );
     }
     listNotebookDocuments() {
-        return ( [...this._models].map(e => e[1].model));
+        return (
+             ([...this._models].map(e => e[1].model))
+        );
     }
     _onWillDisposeDocument(model) {
         const modelData = this._models.get(model.uri);
@@ -596,7 +604,7 @@ let NotebookService = class NotebookService extends Disposable {
         }
     }
     getOutputMimeTypeInfo(textModel, kernelProvides, output) {
-        const sorted = this._displayOrder.sort(( new Set(( output.outputs.map(op => op.mime)))));
+        const sorted = this._displayOrder.sort(( (new Set( (output.outputs.map(op => op.mime))))));
         const notebookProviderInfo = this.notebookProviderInfoStore.get(textModel.viewType);
         return sorted
             .flatMap(mimeType => this._notebookRenderersInfoStore.findBestRenderers(notebookProviderInfo, mimeType, kernelProvides))
@@ -631,13 +639,13 @@ let NotebookService = class NotebookService extends Disposable {
         return undefined;
     }
 };
-NotebookService = NotebookService_1 = ( __decorate([
-    ( __param(0, IExtensionService)),
-    ( __param(1, IConfigurationService)),
-    ( __param(2, IAccessibilityService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IStorageService)),
-    ( __param(5, INotebookDocumentService))
-], NotebookService));
+NotebookService = NotebookService_1 = ( (__decorate([
+    ( (__param(0, IExtensionService))),
+    ( (__param(1, IConfigurationService))),
+    ( (__param(2, IAccessibilityService))),
+    ( (__param(3, IInstantiationService))),
+    ( (__param(4, IStorageService))),
+    ( (__param(5, INotebookDocumentService)))
+], NotebookService)));
 
 export { NotebookOutputRendererInfoStore, NotebookProviderInfoStore, NotebookService };

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

@@ -11,7 +11,7 @@ let NotebookEditorWorkerServiceImpl = class NotebookEditorWorkerServiceImpl exte
         this._workerManager = this._register(( new WorkerManager(notebookService)));
     }
     canComputeDiff(original, modified) {
-        throw new Error('Method not implemented.');
+        throw ( new Error('Method not implemented.'));
     }
     computeDiff(original, modified) {
         return this._workerManager.withWorker().then(client => {
@@ -151,7 +151,7 @@ class NotebookWorkerClient extends Disposable {
         this._modelManager = null;
     }
     fhr(method, args) {
-        throw new Error(`Not implemented!`);
+        throw ( new Error(`Not implemented!`));
     }
     computeDiff(original, modified) {
         return this._withSyncedResources([original, modified]).then(proxy => {

package/vscode/src/vs/workbench/contrib/notebook/common/model/cellEdit.js

@@ -15,13 +15,13 @@ class MoveCellEdit {
     }
     undo() {
         if (!this.editingDelegate.moveCell) {
-            throw new Error('Notebook Move Cell not implemented for Undo/Redo');
+            throw ( new Error('Notebook Move Cell not implemented for Undo/Redo'));
         }
         this.editingDelegate.moveCell(this.toIndex, this.length, this.fromIndex, this.endSelections, this.beforedSelections);
     }
     redo() {
         if (!this.editingDelegate.moveCell) {
-            throw new Error('Notebook Move Cell not implemented for Undo/Redo');
+            throw ( new Error('Notebook Move Cell not implemented for Undo/Redo'));
         }
         this.editingDelegate.moveCell(this.fromIndex, this.length, this.toIndex, this.beforedSelections, this.endSelections);
     }
@@ -47,7 +47,7 @@ class SpliceCellsEdit {
     }
     undo() {
         if (!this.editingDelegate.replaceCell) {
-            throw new Error('Notebook Replace Cell not implemented for Undo/Redo');
+            throw ( new Error('Notebook Replace Cell not implemented for Undo/Redo'));
         }
         this.diffs.forEach(diff => {
             this.editingDelegate.replaceCell(diff[0], diff[2].length, diff[1], this.beforeHandles);
@@ -55,7 +55,7 @@ class SpliceCellsEdit {
     }
     redo() {
         if (!this.editingDelegate.replaceCell) {
-            throw new Error('Notebook Replace Cell not implemented for Undo/Redo');
+            throw ( new Error('Notebook Replace Cell not implemented for Undo/Redo'));
         }
         this.diffs.reverse().forEach(diff => {
             this.editingDelegate.replaceCell(diff[0], diff[1].length, diff[2], this.endHandles);

package/vscode/src/vs/workbench/contrib/notebook/common/model/notebookTextModel.js

@@ -441,7 +441,7 @@ let NotebookTextModel = NotebookTextModel_1 = class NotebookTextModel extends Di
                 }
             }
             else if (edit.editType !== 5 ) {
-                throw new Error('Invalid cell edit');
+                throw ( new Error('Invalid cell edit'));
             }
             return {
                 edit,
@@ -973,7 +973,7 @@ let NotebookTextModel = NotebookTextModel_1 = class NotebookTextModel extends Di
     }
     _assertIndex(index) {
         if (this._indexIsInvalid(index)) {
-            throw new Error(`model index out of range ${index}`);
+            throw ( new Error(`model index out of range ${index}`));
         }
     }
     _indexIsInvalid(index) {

package/vscode/src/vs/workbench/contrib/notebook/common/notebookDiffEditorInput.js

@@ -46,10 +46,14 @@ let NotebookDiffEditorInput = class NotebookDiffEditorInput extends DiffEditorIn
         ]);
         this._cachedModel?.dispose();
         if (!modifiedEditorModel) {
-            throw new Error(`Fail to resolve modified editor model for resource ${this.modified.resource} with notebookType ${this.viewType}`);
+            throw ( new Error(
+                `Fail to resolve modified editor model for resource ${this.modified.resource} with notebookType ${this.viewType}`
+            ));
         }
         if (!originalEditorModel) {
-            throw new Error(`Fail to resolve original editor model for resource ${this.original.resource} with notebookType ${this.viewType}`);
+            throw ( new Error(
+                `Fail to resolve original editor model for resource ${this.original.resource} with notebookType ${this.viewType}`
+            ));
         }
         this._originalTextModel = originalEditorModel;
         this._modifiedTextModel = modifiedEditorModel;

package/vscode/src/vs/workbench/contrib/notebook/common/notebookEditorModelResolverServiceImpl.js

@@ -132,7 +132,7 @@ let NotebookModelResolverServiceImpl = class NotebookModelResolverServiceImpl {
             if (!arg0.untitledResource) {
                 const info = this._notebookService.getContributedNotebookType(assertIsDefined(viewType));
                 if (!info) {
-                    throw new Error('UNKNOWN view type: ' + viewType);
+                    throw ( new Error('UNKNOWN view type: ' + viewType));
                 }
                 const suffix = NotebookProviderInfo.possibleFileEnding(info.selectors) ?? '';
                 for (let counter = 1;; counter++) {
@@ -154,7 +154,7 @@ let NotebookModelResolverServiceImpl = class NotebookModelResolverServiceImpl {
             }
         }
         if (resource.scheme === CellUri.scheme) {
-            throw new Error(`CANNOT open a cell-uri as notebook. Tried with ${resource.toString()}`);
+            throw ( new Error(`CANNOT open a cell-uri as notebook. Tried with ${( resource.toString())}`));
         }
         resource = this._uriIdentService.asCanonicalUri(resource);
         const existingViewType = this._notebookService.getNotebookTextModel(resource)?.viewType;
@@ -170,13 +170,15 @@ let NotebookModelResolverServiceImpl = class NotebookModelResolverServiceImpl {
             }
         }
         if (!viewType) {
-            throw new Error(`Missing viewType for '${resource}'`);
+            throw ( new Error(`Missing viewType for '${resource}'`));
         }
         if (existingViewType && existingViewType !== viewType) {
             await this._onWillFailWithConflict.fireAsync({ resource, viewType }, CancellationToken.None);
             const existingViewType2 = this._notebookService.getNotebookTextModel(resource)?.viewType;
             if (existingViewType2 && existingViewType2 !== viewType) {
-                throw new Error(`A notebook with view type '${existingViewType2}' already exists for '${resource}', CANNOT create another notebook with view type ${viewType}`);
+                throw ( new Error(
+                    `A notebook with view type '${existingViewType2}' already exists for '${resource}', CANNOT create another notebook with view type ${viewType}`
+                ));
             }
         }
         const reference = this._data.acquire(( resource.toString()), viewType, hasAssociatedFilePath, limits);

package/vscode/src/vs/workbench/contrib/notebook/common/services/notebookSimpleWorker.js

@@ -108,7 +108,7 @@ class MirrorNotebookDocument {
     }
     _assertIndex(index) {
         if (index < 0 || index >= this.cells.length) {
-            throw new Error(`Illegal index ${index}. Cells length: ${this.cells.length}`);
+            throw ( new Error(`Illegal index ${index}. Cells length: ${this.cells.length}`));
         }
     }
     _spliceNotebookCells(splices) {