@codingame/monaco-vscode-extensions-service-override 25.1.1 → 26.0.0

package/vscode/src/vs/workbench/api/browser/mainThreadConsole.js

@@ -15,22 +15,16 @@ let MainThreadConsole = class MainThreadConsole {
         const devOpts = parseExtensionDevOptions(this._environmentService);
         this._isExtensionDevTestFromCli = devOpts.isExtensionDevTestFromCli;
     }
-    dispose() {
-    }
+    dispose() {}
     $logExtensionHostMessage(entry) {
         if (this._isExtensionDevTestFromCli) {
             logRemoteEntry(this._logService, entry);
-        }
-        else {
-            logRemoteEntryIfError(this._logService, entry, 'Extension Host');
-            log(entry, 'Extension Host');
+        } else {
+            logRemoteEntryIfError(this._logService, entry, "Extension Host");
+            log(entry, "Extension Host");
         }
     }
 };
-MainThreadConsole = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadConsole),
-    ( __param(1, IEnvironmentService)),
-    ( __param(2, ILogService))
-], MainThreadConsole);
+MainThreadConsole = __decorate([extHostNamedCustomer(MainContext.MainThreadConsole), ( __param(1, IEnvironmentService)), ( __param(2, ILogService))], MainThreadConsole);
 
 export { MainThreadConsole };

package/vscode/src/vs/workbench/api/browser/mainThreadCustomEditors.js

@@ -41,12 +41,26 @@ import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/plat
 
 var MainThreadCustomEditorModel_1;
 var CustomEditorModelType;
-(function (CustomEditorModelType) {
+(function(CustomEditorModelType) {
     CustomEditorModelType[CustomEditorModelType["Custom"] = 0] = "Custom";
     CustomEditorModelType[CustomEditorModelType["Text"] = 1] = "Text";
 })(CustomEditorModelType || (CustomEditorModelType = {}));
 let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
-    constructor(context, mainThreadWebview, mainThreadWebviewPanels, extensionService, storageService, workingCopyService, workingCopyFileService, _customEditorService, _editorGroupService, _editorService, _instantiationService, _webviewWorkbenchService, _uriIdentityService) {
+    constructor(
+        context,
+        mainThreadWebview,
+        mainThreadWebviewPanels,
+        extensionService,
+        storageService,
+        workingCopyService,
+        workingCopyFileService,
+        _customEditorService,
+        _editorGroupService,
+        _editorService,
+        _instantiationService,
+        _webviewWorkbenchService,
+        _uriIdentityService
+    ) {
         super();
         this.mainThreadWebview = mainThreadWebview;
         this.mainThreadWebviewPanels = mainThreadWebviewPanels;
@@ -58,9 +72,9 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
         this._uriIdentityService = _uriIdentityService;
         this._editorProviders = this._register(( new DisposableMap()));
         this._editorRenameBackups = ( new Map());
-        this._webviewOriginStore = ( new ExtensionKeyedWebviewOriginStore('mainThreadCustomEditors.origins', storageService));
+        this._webviewOriginStore = ( new ExtensionKeyedWebviewOriginStore("mainThreadCustomEditors.origins", storageService));
         this._proxyCustomEditors = ( context.getProxy(ExtHostContext.ExtHostCustomEditors));
-        this._register(workingCopyFileService.registerWorkingCopyProvider((editorResource) => {
+        this._register(workingCopyFileService.registerWorkingCopyProvider(editorResource => {
             const matchedWorkingCopies = [];
             for (const workingCopy of workingCopyService.workingCopies) {
                 if (workingCopy instanceof MainThreadCustomEditorModel) {
@@ -72,23 +86,63 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
             return matchedWorkingCopies;
         }));
         this._register(_webviewWorkbenchService.registerResolver({
-            canResolve: (webview) => {
+            canResolve: webview => {
                 if (webview instanceof CustomEditorInput) {
                     extensionService.activateByEvent(`onCustomEditor:${webview.viewType}`);
                 }
                 return false;
             },
-            resolveWebview: () => { throw ( new Error('not implemented')); }
+            resolveWebview: () => {
+                throw ( new Error("not implemented"));
+            }
         }));
-        this._register(workingCopyFileService.onWillRunWorkingCopyFileOperation(async (e) => this.onWillRunWorkingCopyFileOperation(e)));
-    }
-    $registerTextEditorProvider(extensionData, viewType, options, capabilities, serializeBuffersForPostMessage) {
-        this.registerEditorProvider(CustomEditorModelType.Text, reviveWebviewExtension(extensionData), viewType, options, capabilities, true, serializeBuffersForPostMessage);
-    }
-    $registerCustomEditorProvider(extensionData, viewType, options, supportsMultipleEditorsPerDocument, serializeBuffersForPostMessage) {
-        this.registerEditorProvider(CustomEditorModelType.Custom, reviveWebviewExtension(extensionData), viewType, options, {}, supportsMultipleEditorsPerDocument, serializeBuffersForPostMessage);
-    }
-    registerEditorProvider(modelType, extension, viewType, options, capabilities, supportsMultipleEditorsPerDocument, serializeBuffersForPostMessage) {
+        this._register(
+            workingCopyFileService.onWillRunWorkingCopyFileOperation(async e => this.onWillRunWorkingCopyFileOperation(e))
+        );
+    }
+    $registerTextEditorProvider(
+        extensionData,
+        viewType,
+        options,
+        capabilities,
+        serializeBuffersForPostMessage
+    ) {
+        this.registerEditorProvider(
+            CustomEditorModelType.Text,
+            reviveWebviewExtension(extensionData),
+            viewType,
+            options,
+            capabilities,
+            true,
+            serializeBuffersForPostMessage
+        );
+    }
+    $registerCustomEditorProvider(
+        extensionData,
+        viewType,
+        options,
+        supportsMultipleEditorsPerDocument,
+        serializeBuffersForPostMessage
+    ) {
+        this.registerEditorProvider(
+            CustomEditorModelType.Custom,
+            reviveWebviewExtension(extensionData),
+            viewType,
+            options,
+            {},
+            supportsMultipleEditorsPerDocument,
+            serializeBuffersForPostMessage
+        );
+    }
+    registerEditorProvider(
+        modelType,
+        extension,
+        viewType,
+        options,
+        capabilities,
+        supportsMultipleEditorsPerDocument,
+        serializeBuffersForPostMessage
+    ) {
         if (( this._editorProviders.has(viewType))) {
             throw ( new Error(`Provider for ${viewType} already registered`));
         }
@@ -97,14 +151,16 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
             supportsMultipleEditorsPerDocument
         }));
         disposables.add(this._webviewWorkbenchService.registerResolver({
-            canResolve: (webviewInput) => {
+            canResolve: webviewInput => {
                 return webviewInput instanceof CustomEditorInput && webviewInput.viewType === viewType;
             },
             resolveWebview: async (webviewInput, cancellation) => {
                 const handle = generateUuid();
                 const resource = webviewInput.resource;
                 webviewInput.webview.origin = this._webviewOriginStore.getOrigin(viewType, extension.id);
-                this.mainThreadWebviewPanels.addWebviewInput(handle, webviewInput, { serializeBuffersForPostMessage });
+                this.mainThreadWebviewPanels.addWebviewInput(handle, webviewInput, {
+                    serializeBuffersForPostMessage
+                });
                 webviewInput.webview.options = options;
                 webviewInput.webview.extension = extension;
                 let backupId = webviewInput.backupId;
@@ -115,9 +171,10 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
                 }
                 let modelRef;
                 try {
-                    modelRef = await this.getOrCreateCustomEditorModel(modelType, resource, viewType, { backupId }, cancellation);
-                }
-                catch (error) {
+                    modelRef = await this.getOrCreateCustomEditorModel(modelType, resource, viewType, {
+                        backupId
+                    }, cancellation);
+                } catch (error) {
                     onUnexpectedError(error);
                     webviewInput.webview.setHtml(this.mainThreadWebview.getWebviewResolvedFailedContent(viewType));
                     return;
@@ -128,6 +185,7 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
                 }
                 const disposeSub = webviewInput.webview.onDidDispose(() => {
                     disposeSub.dispose();
+                    inputDisposeSub.dispose();
                     if (modelRef.object.isDirty()) {
                         const sub = modelRef.object.onDidChangeDirty(() => {
                             if (!modelRef.object.isDirty()) {
@@ -139,8 +197,13 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
                     }
                     modelRef.dispose();
                 });
+                const inputDisposeSub = webviewInput.onWillDispose(() => {
+                    inputDisposeSub.dispose();
+                    disposeSub.dispose();
+                    modelRef.dispose();
+                });
                 if (capabilities.supportsMove) {
-                    webviewInput.onMove(async (newResource) => {
+                    webviewInput.onMove(async newResource => {
                         const oldModel = modelRef;
                         modelRef = await this.getOrCreateCustomEditorModel(modelType, newResource, viewType, {}, CancellationToken.None);
                         this._proxyCustomEditors.$onMoveCustomEditor(handle, newResource, viewType);
@@ -153,10 +216,9 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
                         title: webviewInput.getTitle(),
                         contentOptions: webviewInput.webview.contentOptions,
                         options: webviewInput.webview.options,
-                        active: webviewInput === this._editorService.activeEditor,
+                        active: webviewInput === this._editorService.activeEditor
                     }, editorGroupToColumn(this._editorGroupService, webviewInput.group || 0), cancellation);
-                }
-                catch (error) {
+                } catch (error) {
                     onUnexpectedError(error);
                     webviewInput.webview.setHtml(this.mainThreadWebview.getWebviewResolvedFailedContent(viewType));
                     modelRef.dispose();
@@ -179,19 +241,28 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
             return existingModel;
         }
         switch (modelType) {
-            case CustomEditorModelType.Text:
-                {
-                    const model = CustomTextEditorModel.create(this._instantiationService, viewType, resource);
-                    return this._customEditorService.models.add(resource, viewType, model);
-                }
-            case CustomEditorModelType.Custom:
-                {
-                    const model = MainThreadCustomEditorModel.create(this._instantiationService, this._proxyCustomEditors, viewType, resource, options, () => {
-                        return Array.from(this.mainThreadWebviewPanels.webviewInputs)
-                            .filter(editor => editor instanceof CustomEditorInput && isEqual(editor.resource, resource));
-                    }, cancellation);
-                    return this._customEditorService.models.add(resource, viewType, model);
-                }
+        case CustomEditorModelType.Text:
+            {
+                const model = CustomTextEditorModel.create(this._instantiationService, viewType, resource);
+                return this._customEditorService.models.add(resource, viewType, model);
+            }
+        case CustomEditorModelType.Custom:
+            {
+                const model = MainThreadCustomEditorModel.create(
+                    this._instantiationService,
+                    this._proxyCustomEditors,
+                    viewType,
+                    resource,
+                    options,
+                    () => {
+                        return Array.from(this.mainThreadWebviewPanels.webviewInputs).filter(
+                            editor => editor instanceof CustomEditorInput && isEqual(editor.resource, resource)
+                        );
+                    },
+                    cancellation
+                );
+                return this._customEditorService.models.add(resource, viewType, model);
+            }
         }
     }
     async $onDidEdit(resourceComponents, viewType, editId, label) {
@@ -206,7 +277,7 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
         const resource = URI.revive(resourceComponents);
         const model = await this._customEditorService.models.get(resource, viewType);
         if (!model || !(model instanceof MainThreadCustomEditorModel)) {
-            throw ( new Error('Could not find model for webview editor'));
+            throw ( new Error("Could not find model for webview editor"));
         }
         return model;
     }
@@ -232,28 +303,21 @@ let MainThreadCustomEditors = class MainThreadCustomEditors extends Disposable {
         })());
     }
 };
-MainThreadCustomEditors = ( __decorate([
-    ( __param(3, IExtensionService)),
-    ( __param(4, IStorageService)),
-    ( __param(5, IWorkingCopyService)),
-    ( __param(6, IWorkingCopyFileService)),
-    ( __param(7, ICustomEditorService)),
-    ( __param(8, IEditorGroupsService)),
-    ( __param(9, IEditorService)),
-    ( __param(10, IInstantiationService)),
-    ( __param(11, IWebviewWorkbenchService)),
-    ( __param(12, IUriIdentityService))
-], MainThreadCustomEditors));
+MainThreadCustomEditors = ( __decorate([( __param(3, IExtensionService)), ( __param(4, IStorageService)), ( __param(5, IWorkingCopyService)), ( __param(6, IWorkingCopyFileService)), ( __param(7, ICustomEditorService)), ( __param(8, IEditorGroupsService)), ( __param(9, IEditorService)), ( __param(10, IInstantiationService)), ( __param(11, IWebviewWorkbenchService)), ( __param(12, IUriIdentityService))], MainThreadCustomEditors));
 var HotExitState;
-(function (HotExitState) {
+(function(HotExitState) {
     let Type;
-    (function (Type) {
+    (function(Type) {
         Type[Type["Allowed"] = 0] = "Allowed";
         Type[Type["NotAllowed"] = 1] = "NotAllowed";
         Type[Type["Pending"] = 2] = "Pending";
     })(Type = HotExitState.Type || (HotExitState.Type = {}));
-    HotExitState.Allowed = ( Object.freeze({ type: Type.Allowed }));
-    HotExitState.NotAllowed = ( Object.freeze({ type: Type.NotAllowed }));
+    HotExitState.Allowed = ( Object.freeze({
+        type: Type.Allowed
+    }));
+    HotExitState.NotAllowed = ( Object.freeze({
+        type: Type.NotAllowed
+    }));
     class Pending {
         constructor(operation) {
             this.operation = operation;
@@ -263,17 +327,55 @@ var HotExitState;
     HotExitState.Pending = Pending;
 })(HotExitState || (HotExitState = {}));
 let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThreadCustomEditorModel extends ResourceWorkingCopy {
-    static async create(instantiationService, proxy, viewType, resource, options, getEditors, cancellation) {
+    static async create(
+        instantiationService,
+        proxy,
+        viewType,
+        resource,
+        options,
+        getEditors,
+        cancellation
+    ) {
         const editors = getEditors();
         let untitledDocumentData;
         if (editors.length !== 0) {
             untitledDocumentData = editors[0].untitledDocumentData;
         }
-        const { editable } = await proxy.$createCustomDocument(resource, viewType, options.backupId, untitledDocumentData, cancellation);
-        return instantiationService.createInstance(MainThreadCustomEditorModel_1, proxy, viewType, resource, !!options.backupId, editable, !!untitledDocumentData, getEditors);
-    }
-    constructor(_proxy, _viewType, _editorResource, fromBackup, _editable, startDirty, _getEditors, _fileDialogService, fileService, _labelService, _undoService, _environmentService, workingCopyService, _pathService, extensionService) {
-        super(MainThreadCustomEditorModel_1.toWorkingCopyResource(_viewType, _editorResource), fileService);
+        const {
+            editable
+        } = await proxy.$createCustomDocument(resource, viewType, options.backupId, untitledDocumentData, cancellation);
+        return instantiationService.createInstance(
+            MainThreadCustomEditorModel_1,
+            proxy,
+            viewType,
+            resource,
+            !!options.backupId,
+            editable,
+            !!untitledDocumentData,
+            getEditors
+        );
+    }
+    constructor(
+        _proxy,
+        _viewType,
+        _editorResource,
+        fromBackup,
+        _editable,
+        startDirty,
+        _getEditors,
+        _fileDialogService,
+        fileService,
+        _labelService,
+        _undoService,
+        _environmentService,
+        workingCopyService,
+        _pathService,
+        extensionService
+    ) {
+        super(
+            MainThreadCustomEditorModel_1.toWorkingCopyResource(_viewType, _editorResource),
+            fileService
+        );
         this._proxy = _proxy;
         this._viewType = _viewType;
         this._editorResource = _editorResource;
@@ -303,7 +405,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
             this._register(workingCopyService.registerWorkingCopy(this));
             this._register(extensionService.onWillStop(e => {
                 e.veto(true, ( localize(
-                    2501,
+                    2504,
                     "An extension provided editor for '{0}' is still open that would close otherwise.",
                     this.name
                 )));
@@ -321,13 +423,16 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
         super.dispose();
     }
     static toWorkingCopyResource(viewType, resource) {
-        const authority = viewType.replace(/[^a-z0-9\-_]/gi, '-');
-        const path = `/${multibyteAwareBtoa(( resource.with({ query: null, fragment: null }).toString(true)))}`;
+        const authority = viewType.replace(/[^a-z0-9\-_]/gi, "-");
+        const path = `/${multibyteAwareBtoa(( resource.with({
+    query: null,
+    fragment: null
+}).toString(true)))}`;
         return ( URI.from({
             scheme: Schemas.vscodeCustomEditor,
             authority: authority,
             path: path,
-            query: JSON.stringify(resource.toJSON()),
+            query: JSON.stringify(resource.toJSON())
         }));
     }
     get name() {
@@ -359,7 +464,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
     }
     pushEdit(editId, label) {
         if (!this._editable) {
-            throw ( new Error('Document is not editable'));
+            throw ( new Error("Document is not editable"));
         }
         this.change(() => {
             this.spliceEdits(editId);
@@ -368,10 +473,10 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
         this._undoService.pushElement({
             type: UndoRedoElementType.Resource,
             resource: this._editorResource,
-            label: label ?? ( localize(2502, "Edit")),
-            code: 'undoredo.customEditorEdit',
+            label: label ?? ( localize(2505, "Edit")),
+            code: "undoredo.customEditorEdit",
             undo: () => this.undo(),
-            redo: () => this.redo(),
+            redo: () => this.redo()
         });
     }
     changeContent() {
@@ -408,9 +513,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
     spliceEdits(editToInsert) {
         const start = this._currentEditIndex + 1;
         const toRemove = this._edits.length - this._currentEditIndex;
-        const removedEdits = typeof editToInsert === 'number'
-            ? this._edits.splice(start, toRemove, editToInsert)
-            : this._edits.splice(start, toRemove);
+        const removedEdits = typeof editToInsert === "number" ? this._edits.splice(start, toRemove, editToInsert) : this._edits.splice(start, toRemove);
         if (removedEdits.length) {
             this._proxy.$disposeEdits(this._editorResource, this._viewType, removedEdits);
         }
@@ -443,7 +546,10 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
     async save(options) {
         const result = !!(await this.saveCustomEditor(options));
         if (result) {
-            this._onDidSave.fire({ reason: options?.reason, source: options?.source });
+            this._onDidSave.fire({
+                reason: options?.reason,
+                source: options?.source
+            });
         }
         return result;
     }
@@ -471,8 +577,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
                     this._fromBackup = false;
                 });
             }
-        }
-        finally {
+        } finally {
             if (this._ongoingSave === savePromise) {
                 this._ongoingSave = undefined;
             }
@@ -481,7 +586,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
     }
     suggestUntitledSavePath(options) {
         if (!this.isUntitled()) {
-            throw ( new Error('Resource is not untitled'));
+            throw ( new Error("Resource is not untitled"));
         }
         const remoteAuthority = this._environmentService.remoteAuthority;
         const localResource = toLocalResource(this._editorResource, remoteAuthority, this._pathService.defaultUriScheme);
@@ -489,22 +594,27 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
     }
     async saveCustomEditorAs(resource, targetResource, _options) {
         if (this._editable) {
-            await createCancelablePromise(token => this._proxy.$onSaveAs(this._editorResource, this.viewType, targetResource, token));
+            await createCancelablePromise(
+                token => this._proxy.$onSaveAs(this._editorResource, this.viewType, targetResource, token)
+            );
             this.change(() => {
+                this._isDirtyFromContentChange = false;
                 this._savePoint = this._currentEditIndex;
+                this._fromBackup = false;
             });
             return true;
-        }
-        else {
+        } else {
             await this.fileService.copy(resource, targetResource, false );
             return true;
         }
     }
-    get canHotExit() { return typeof this._backupId === 'string' && this._hotExitState.type === HotExitState.Type.Allowed; }
+    get canHotExit() {
+        return typeof this._backupId === "string" && this._hotExitState.type === HotExitState.Type.Allowed;
+    }
     async backup(token) {
         const editors = this._getEditors();
         if (!editors.length) {
-            throw ( new Error('No editors found for resource, cannot back up'));
+            throw ( new Error("No editors found for resource, cannot back up"));
         }
         const primaryEditor = editors[0];
         const backupMeta = {
@@ -512,15 +622,15 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
             editorResource: this._editorResource,
             customTitle: primaryEditor.getWebviewTitle(),
             iconPath: primaryEditor.iconPath,
-            backupId: '',
+            backupId: "",
             extension: primaryEditor.extension ? {
                 id: primaryEditor.extension.id.value,
-                location: primaryEditor.extension.location,
+                location: primaryEditor.extension.location
             } : undefined,
             webview: {
                 origin: primaryEditor.webview.origin,
                 options: primaryEditor.webview.options,
-                state: primaryEditor.webview.state,
+                state: primaryEditor.webview.state
             }
         };
         const backupData = {
@@ -532,12 +642,14 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
         if (this._hotExitState.type === HotExitState.Type.Pending) {
             this._hotExitState.operation.cancel();
         }
-        const pendingState = new HotExitState.Pending(createCancelablePromise(token => this._proxy.$backup(this._editorResource.toJSON(), this.viewType, token)));
+        const pendingState = new HotExitState.Pending(createCancelablePromise(
+            token => this._proxy.$backup(this._editorResource.toJSON(), this.viewType, token)
+        ));
         this._hotExitState = pendingState;
         token.onCancellationRequested(() => {
             pendingState.operation.cancel();
         });
-        let errorMessage = '';
+        let errorMessage = "";
         try {
             const backupId = await pendingState.operation;
             if (this._hotExitState === pendingState) {
@@ -545,8 +657,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
                 backupData.meta.backupId = backupId;
                 this._backupId = backupId;
             }
-        }
-        catch (e) {
+        } catch (e) {
             if (isCancellationError(e)) {
                 throw e;
             }
@@ -563,15 +674,6 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
         throw ( new Error(`Cannot backup in this state: ${errorMessage}`));
     }
 };
-MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = ( __decorate([
-    ( __param(7, IFileDialogService)),
-    ( __param(8, IFileService)),
-    ( __param(9, ILabelService)),
-    ( __param(10, IUndoRedoService)),
-    ( __param(11, IWorkbenchEnvironmentService)),
-    ( __param(12, IWorkingCopyService)),
-    ( __param(13, IPathService)),
-    ( __param(14, IExtensionService))
-], MainThreadCustomEditorModel));
+MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = ( __decorate([( __param(7, IFileDialogService)), ( __param(8, IFileService)), ( __param(9, ILabelService)), ( __param(10, IUndoRedoService)), ( __param(11, IWorkbenchEnvironmentService)), ( __param(12, IWorkingCopyService)), ( __param(13, IPathService)), ( __param(14, IExtensionService))], MainThreadCustomEditorModel));
 
 export { MainThreadCustomEditors };

package/vscode/src/vs/workbench/api/browser/mainThreadDataChannels.js

@@ -15,9 +15,6 @@ let MainThreadDataChannels = class MainThreadDataChannels extends Disposable {
         }));
     }
 };
-MainThreadDataChannels = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadDataChannels),
-    ( __param(1, IDataChannelService))
-], MainThreadDataChannels);
+MainThreadDataChannels = __decorate([extHostNamedCustomer(MainContext.MainThreadDataChannels), ( __param(1, IDataChannelService))], MainThreadDataChannels);
 
 export { MainThreadDataChannels };