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

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

@@ -14,14 +14,18 @@ import { deserializeWebviewMessage, serializeWebviewMessage } from '@codingame/m
 
 var MainThreadWebviews_1;
 let MainThreadWebviews = class MainThreadWebviews extends Disposable {
-    static { MainThreadWebviews_1 = this; }
-    static { this.standardSupportedLinkSchemes = ( new Set([
-        Schemas.http,
-        Schemas.https,
-        Schemas.mailto,
-        Schemas.vscode,
-        'vscode-insider',
-    ])); }
+    static {
+        MainThreadWebviews_1 = this;
+    }
+    static {
+        this.standardSupportedLinkSchemes = ( new Set([
+            Schemas.http,
+            Schemas.https,
+            Schemas.mailto,
+            Schemas.vscode,
+            "vscode-insider"
+        ]));
+    }
     constructor(context, _openerService, _productService) {
         super();
         this._openerService = _openerService;
@@ -31,7 +35,7 @@ let MainThreadWebviews = class MainThreadWebviews extends Disposable {
     }
     addWebview(handle, webview, options) {
         if (( this._webviews.has(handle))) {
-            throw ( new Error('Webview already registered'));
+            throw ( new Error("Webview already registered"));
         }
         this._webviews.set(handle, webview);
         this.hookupWebviewEventDelegate(handle, webview, options);
@@ -50,17 +54,22 @@ let MainThreadWebviews = class MainThreadWebviews extends Disposable {
         if (!webview) {
             return false;
         }
-        const { message, arrayBuffers } = deserializeWebviewMessage(jsonMessage, buffers);
+        const {
+            message,
+            arrayBuffers
+        } = deserializeWebviewMessage(jsonMessage, buffers);
         return webview.postMessage(message, arrayBuffers);
     }
     hookupWebviewEventDelegate(handle, webview, options) {
         const disposables = ( new DisposableStore());
-        disposables.add(webview.onDidClickLink((uri) => this.onDidClickLink(handle, uri)));
-        disposables.add(webview.onMessage((message) => {
+        disposables.add(webview.onDidClickLink(uri => this.onDidClickLink(handle, uri)));
+        disposables.add(webview.onMessage(message => {
             const serialized = serializeWebviewMessage(message.message, options);
             this._proxy.$onMessage(handle, serialized.message, ( new SerializableObjectWithBuffers(serialized.buffers)));
         }));
-        disposables.add(webview.onMissingCsp((extension) => this._proxy.$onMissingCsp(handle, extension.value)));
+        disposables.add(
+            webview.onMissingCsp(extension => this._proxy.$onMissingCsp(handle, extension.value))
+        );
         disposables.add(webview.onDidDispose(() => {
             disposables.dispose();
             this._webviews.delete(handle);
@@ -69,7 +78,12 @@ let MainThreadWebviews = class MainThreadWebviews extends Disposable {
     onDidClickLink(handle, link) {
         const webview = this.getWebview(handle);
         if (this.isSupportedLink(webview, ( URI.parse(link)))) {
-            this._openerService.open(link, { fromUserGesture: true, allowContributedOpeners: true, allowCommands: Array.isArray(webview.contentOptions.enableCommandUris) || webview.contentOptions.enableCommandUris === true, fromWorkspace: true });
+            this._openerService.open(link, {
+                fromUserGesture: true,
+                allowContributedOpeners: true,
+                allowCommands: Array.isArray(webview.contentOptions.enableCommandUris) || webview.contentOptions.enableCommandUris === true,
+                fromWorkspace: true
+            });
         }
     }
     isSupportedLink(webview, link) {
@@ -99,23 +113,20 @@ let MainThreadWebviews = class MainThreadWebviews extends Disposable {
     }
     getWebviewResolvedFailedContent(viewType) {
         return `<!DOCTYPE html>
-		<html>
-			<head>
-				<meta http-equiv="Content-type" content="text/html;charset=UTF-8">
-				<meta http-equiv="Content-Security-Policy" content="default-src 'none';">
-			</head>
-			<body>${( localize(2558, "An error occurred while loading view: {0}", escape(viewType)))}</body>
-		</html>`;
+        <html>
+            <head>
+                <meta http-equiv="Content-type" content="text/html;charset=UTF-8">
+                <meta http-equiv="Content-Security-Policy" content="default-src 'none';">
+            </head>
+            <body>${( localize(2561, "An error occurred while loading view: {0}", escape(viewType)))}</body>
+        </html>`;
     }
 };
-MainThreadWebviews = MainThreadWebviews_1 = ( __decorate([
-    ( __param(1, IOpenerService)),
-    ( __param(2, IProductService))
-], MainThreadWebviews));
+MainThreadWebviews = MainThreadWebviews_1 = ( __decorate([( __param(1, IOpenerService)), ( __param(2, IProductService))], MainThreadWebviews));
 function reviveWebviewExtension(extensionData) {
     return {
         id: extensionData.id,
-        location: URI.revive(extensionData.location),
+        location: URI.revive(extensionData.location)
     };
 }
 function reviveWebviewContentOptions(webviewOptions) {
@@ -124,7 +135,7 @@ function reviveWebviewContentOptions(webviewOptions) {
         allowForms: webviewOptions.enableForms,
         enableCommandUris: webviewOptions.enableCommandUris,
         localResourceRoots: Array.isArray(webviewOptions.localResourceRoots) ? ( webviewOptions.localResourceRoots.map(r => URI.revive(r))) : undefined,
-        portMapping: webviewOptions.portMapping,
+        portMapping: webviewOptions.portMapping
     };
 }
 

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

@@ -25,7 +25,7 @@ let MainThreadWindow = class MainThreadWindow {
         this.disposables.dispose();
     }
     registerNativeHandle() {
-        Event.latch(this.hostService.onDidChangeActiveWindow)(async (windowId) => {
+        Event.latch(this.hostService.onDidChangeActiveWindow)(async windowId => {
             const handle = await this.hostService.getNativeWindowHandle(windowId);
             this.proxy.$onDidChangeActiveNativeWindowHandle(handle ? encodeBase64(handle) : undefined);
         }, this, this.disposables);
@@ -33,7 +33,7 @@ let MainThreadWindow = class MainThreadWindow {
     $getInitialState() {
         return Promise.resolve({
             isFocused: this.hostService.hasFocus,
-            isActive: this.userActivityService.isActive,
+            isActive: this.userActivityService.isActive
         });
     }
     async $openUri(uriComponents, uriString, options) {
@@ -41,14 +41,13 @@ let MainThreadWindow = class MainThreadWindow {
         let target;
         if (uriString && ( ( URI.parse(uriString)).toString()) === ( uri.toString())) {
             target = uriString;
-        }
-        else {
+        } else {
             target = uri;
         }
         return this.openerService.open(target, {
             openExternal: true,
             allowTunneling: options.allowTunneling,
-            allowContributedOpeners: options.allowContributedOpeners,
+            allowContributedOpeners: options.allowContributedOpeners
         });
     }
     async $asExternalUri(uriComponents, options) {
@@ -56,11 +55,6 @@ let MainThreadWindow = class MainThreadWindow {
         return result.resolved;
     }
 };
-MainThreadWindow = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadWindow),
-    ( __param(1, IHostService)),
-    ( __param(2, IOpenerService)),
-    ( __param(3, IUserActivityService))
-], MainThreadWindow);
+MainThreadWindow = __decorate([extHostNamedCustomer(MainContext.MainThreadWindow), ( __param(1, IHostService)), ( __param(2, IOpenerService)), ( __param(3, IUserActivityService))], MainThreadWindow);
 
 export { MainThreadWindow };

package/vscode/src/vs/workbench/api/browser/mainThreadWorkspace.d.ts

@@ -17,7 +17,7 @@ import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench
 import { IPatternInfo } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/search/common/search";
 import { ISearchService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/search/common/search.service";
 import { IWorkspaceEditingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/workspaces/common/workspaceEditing.service";
-import { ITextSearchComplete, MainThreadWorkspaceShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+import { ITextSearchComplete, MainThreadWorkspaceShape, ResourceTrustRequestOptionsDto } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
 import { IEditSessionIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/editSessions.service";
 import { ICanonicalUriService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/canonicalUri.service";
 import { ITextFileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service";
@@ -61,9 +61,12 @@ export declare class MainThreadWorkspace implements MainThreadWorkspaceShape {
     $lookupAuthorization(authInfo: AuthInfo): Promise<Credentials | undefined>;
     $lookupKerberosAuthorization(url: string): Promise<string | undefined>;
     $loadCertificates(): Promise<string[]>;
+    $requestResourceTrust(optionsDto: ResourceTrustRequestOptionsDto): Promise<boolean | undefined>;
     $requestWorkspaceTrust(options?: WorkspaceTrustRequestOptions): Promise<boolean | undefined>;
+    $isResourceTrusted(resource: UriComponents): Promise<boolean>;
     private isWorkspaceTrusted;
     private _onDidGrantWorkspaceTrust;
+    private _onDidChangeWorkspaceTrustedFolders;
     private registeredEditSessionProviders;
     $registerEditSessionIdentityProvider(handle: number, scheme: string): void;
     $unregisterEditSessionIdentityProvider(handle: number): void;

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

@@ -29,7 +29,24 @@ import { revive } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marsh
 import { ITextFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service';
 
 let MainThreadWorkspace = class MainThreadWorkspace {
-    constructor(extHostContext, _searchService, _contextService, _editSessionIdentityService, _canonicalUriService, _editorService, _workspaceEditingService, _notificationService, _requestService, _instantiationService, _labelService, _environmentService, fileService, _workspaceTrustManagementService, _workspaceTrustRequestService, _textFileService) {
+    constructor(
+        extHostContext,
+        _searchService,
+        _contextService,
+        _editSessionIdentityService,
+        _canonicalUriService,
+        _editorService,
+        _workspaceEditingService,
+        _notificationService,
+        _requestService,
+        _instantiationService,
+        _labelService,
+        _environmentService,
+        fileService,
+        _workspaceTrustManagementService,
+        _workspaceTrustRequestService,
+        _textFileService
+    ) {
         this._searchService = _searchService;
         this._contextService = _contextService;
         this._editSessionIdentityService = _editSessionIdentityService;
@@ -53,13 +70,15 @@ let MainThreadWorkspace = class MainThreadWorkspace {
         const workspace = this._contextService.getWorkspace();
         if (workspace.configuration && !isNative && !fileService.hasProvider(workspace.configuration)) {
             this._proxy.$initializeWorkspace(this.getWorkspaceData(workspace), this.isWorkspaceTrusted());
-        }
-        else {
-            this._contextService.getCompleteWorkspace().then(workspace => this._proxy.$initializeWorkspace(this.getWorkspaceData(workspace), this.isWorkspaceTrusted()));
+        } else {
+            this._contextService.getCompleteWorkspace().then(
+                workspace => this._proxy.$initializeWorkspace(this.getWorkspaceData(workspace), this.isWorkspaceTrusted())
+            );
         }
         this._contextService.onDidChangeWorkspaceFolders(this._onDidChangeWorkspace, this, this._toDispose);
         this._contextService.onDidChangeWorkbenchState(this._onDidChangeWorkspace, this, this._toDispose);
         this._workspaceTrustManagementService.onDidChangeTrust(this._onDidGrantWorkspaceTrust, this, this._toDispose);
+        this._workspaceTrustManagementService.onDidChangeTrustedFolders(this._onDidChangeWorkspaceTrustedFolders, this, this._toDispose);
     }
     dispose() {
         this._toDispose.dispose();
@@ -69,8 +88,16 @@ let MainThreadWorkspace = class MainThreadWorkspace {
         }
     }
     $updateWorkspaceFolders(extensionName, index, deleteCount, foldersToAdd) {
-        const workspaceFoldersToAdd = ( foldersToAdd.map(f => ({ uri: URI.revive(f.uri), name: f.name })));
-        this._notificationService.status(this.getStatusMessage(extensionName, workspaceFoldersToAdd.length, deleteCount), { hideAfter: 10 * 1000  });
+        const workspaceFoldersToAdd = ( foldersToAdd.map(f => ({
+            uri: URI.revive(f.uri),
+            name: f.name
+        })));
+        this._notificationService.status(
+            this.getStatusMessage(extensionName, workspaceFoldersToAdd.length, deleteCount),
+            {
+                hideAfter: 10 * 1000
+            }
+        );
         return this._workspaceEditingService.updateFolders(index, deleteCount, workspaceFoldersToAdd, true);
     }
     getStatusMessage(extensionName, addCount, removeCount) {
@@ -79,11 +106,10 @@ let MainThreadWorkspace = class MainThreadWorkspace {
         const wantsToDelete = removeCount > 0;
         if (wantsToAdd && !wantsToDelete) {
             if (addCount === 1) {
-                message = ( localize(2559, "Extension '{0}' added 1 folder to the workspace", extensionName));
-            }
-            else {
+                message = ( localize(2562, "Extension '{0}' added 1 folder to the workspace", extensionName));
+            } else {
                 message = ( localize(
-                    2560,
+                    2563,
                     "Extension '{0}' added {1} folders to the workspace",
                     extensionName,
                     addCount
@@ -92,11 +118,10 @@ let MainThreadWorkspace = class MainThreadWorkspace {
         }
         else if (wantsToDelete && !wantsToAdd) {
             if (removeCount === 1) {
-                message = ( localize(2561, "Extension '{0}' removed 1 folder from the workspace", extensionName));
-            }
-            else {
+                message = ( localize(2564, "Extension '{0}' removed 1 folder from the workspace", extensionName));
+            } else {
                 message = ( localize(
-                    2562,
+                    2565,
                     "Extension '{0}' removed {1} folders from the workspace",
                     extensionName,
                     removeCount
@@ -104,7 +129,7 @@ let MainThreadWorkspace = class MainThreadWorkspace {
             }
         }
         else {
-            message = ( localize(2563, "Extension '{0}' changed folders of the workspace", extensionName));
+            message = ( localize(2566, "Extension '{0}' changed folders of the workspace", extensionName));
         }
         return message;
     }
@@ -121,7 +146,8 @@ let MainThreadWorkspace = class MainThreadWorkspace {
             folders: workspace.folders,
             id: workspace.id,
             name: this._labelService.getWorkspaceLabel(workspace),
-            transient: workspace.transient
+            transient: workspace.transient,
+            isAgentSessionsWorkspace: workspace.isAgentSessionsWorkspace
         };
     }
     $startFileSearch(_includeFolder, options, token) {
@@ -142,14 +168,16 @@ let MainThreadWorkspace = class MainThreadWorkspace {
         const workspace = this._contextService.getWorkspace();
         const folders = folder ? [folder] : ( workspace.folders.map(folder => folder.uri));
         const query = this._queryBuilder.text(pattern, folders, revive(options));
-        query._reason = 'startTextSearch';
-        const onProgress = (p) => {
+        query._reason = "startTextSearch";
+        const onProgress = p => {
             if (p.results) {
                 this._proxy.$handleTextSearchResult(p, requestId);
             }
         };
         const search = this._searchService.textSearch(query, token, onProgress).then(result => {
-            return { limitHit: result.limitHit };
+            return {
+                limitHit: result.limitHit
+            };
         }, err => {
             if (!isCancellationError(err)) {
                 return Promise.reject(err);
@@ -159,11 +187,13 @@ let MainThreadWorkspace = class MainThreadWorkspace {
         return search;
     }
     $checkExists(folders, includes, token) {
-        return this._instantiationService.invokeFunction((accessor) => checkGlobFileExists(accessor, folders, includes, token));
+        return this._instantiationService.invokeFunction(accessor => checkGlobFileExists(accessor, folders, includes, token));
     }
     async $save(uriComponents, options) {
         const uri = URI.revive(uriComponents);
-        const editors = [...this._editorService.findEditors(uri, { supportSideBySide: SideBySideEditor.PRIMARY })];
+        const editors = [...this._editorService.findEditors(uri, {
+            supportSideBySide: SideBySideEditor.PRIMARY
+        })];
         const result = await this._editorService.save(editors, {
             reason: SaveReason.EXPLICIT,
             saveAs: options.saveAs,
@@ -175,12 +205,14 @@ let MainThreadWorkspace = class MainThreadWorkspace {
         if (!result.success) {
             return [];
         }
-        return coalesce(( result.editors.map(
-            editor => EditorResourceAccessor.getCanonicalUri(editor, { supportSideBySide: SideBySideEditor.PRIMARY })
-        )));
+        return coalesce(( result.editors.map(editor => EditorResourceAccessor.getCanonicalUri(editor, {
+            supportSideBySide: SideBySideEditor.PRIMARY
+        }))));
     }
     $saveAll(includeUntitled) {
-        return this._editorService.saveAll({ includeUntitled }).then(res => res.success);
+        return this._editorService.saveAll({
+            includeUntitled
+        }).then(res => res.success);
     }
     $resolveProxy(url) {
         return this._requestService.resolveProxy(url);
@@ -194,15 +226,30 @@ let MainThreadWorkspace = class MainThreadWorkspace {
     $loadCertificates() {
         return this._requestService.loadCertificates();
     }
+    $requestResourceTrust(optionsDto) {
+        const options = {
+            ...optionsDto,
+            uri: URI.revive(optionsDto.uri)
+        };
+        return this._workspaceTrustRequestService.requestResourcesTrust(options);
+    }
     $requestWorkspaceTrust(options) {
         return this._workspaceTrustRequestService.requestWorkspaceTrust(options);
     }
+    async $isResourceTrusted(resource) {
+        const uri = URI.revive(resource);
+        const trustInfo = await this._workspaceTrustManagementService.getUriTrustInfo(uri);
+        return trustInfo.trusted;
+    }
     isWorkspaceTrusted() {
         return this._workspaceTrustManagementService.isWorkspaceTrusted();
     }
     _onDidGrantWorkspaceTrust() {
         this._proxy.$onDidGrantWorkspaceTrust();
     }
+    _onDidChangeWorkspaceTrustedFolders() {
+        this._proxy.$onDidChangeWorkspaceTrustedFolders();
+    }
     $registerEditSessionIdentityProvider(handle, scheme) {
         const disposable = this._editSessionIdentityService.registerEditSessionIdentityProvider({
             scheme: scheme,
@@ -250,23 +297,6 @@ let MainThreadWorkspace = class MainThreadWorkspace {
         return this._textFileService.resolveEncoding(URI.revive(resource), options);
     }
 };
-MainThreadWorkspace = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadWorkspace),
-    ( __param(1, ISearchService)),
-    ( __param(2, IWorkspaceContextService)),
-    ( __param(3, IEditSessionIdentityService)),
-    ( __param(4, ICanonicalUriService)),
-    ( __param(5, IEditorService)),
-    ( __param(6, IWorkspaceEditingService)),
-    ( __param(7, INotificationService)),
-    ( __param(8, IRequestService)),
-    ( __param(9, IInstantiationService)),
-    ( __param(10, ILabelService)),
-    ( __param(11, IEnvironmentService)),
-    ( __param(12, IFileService)),
-    ( __param(13, IWorkspaceTrustManagementService)),
-    ( __param(14, IWorkspaceTrustRequestService)),
-    ( __param(15, ITextFileService))
-], MainThreadWorkspace);
+MainThreadWorkspace = __decorate([extHostNamedCustomer(MainContext.MainThreadWorkspace), ( __param(1, ISearchService)), ( __param(2, IWorkspaceContextService)), ( __param(3, IEditSessionIdentityService)), ( __param(4, ICanonicalUriService)), ( __param(5, IEditorService)), ( __param(6, IWorkspaceEditingService)), ( __param(7, INotificationService)), ( __param(8, IRequestService)), ( __param(9, IInstantiationService)), ( __param(10, ILabelService)), ( __param(11, IEnvironmentService)), ( __param(12, IFileService)), ( __param(13, IWorkspaceTrustManagementService)), ( __param(14, IWorkspaceTrustRequestService)), ( __param(15, ITextFileService))], MainThreadWorkspace);
 
 export { MainThreadWorkspace };

package/vscode/src/vs/workbench/api/common/shared/dataTransferCache.js

@@ -20,11 +20,11 @@ class DataTransferFileCache {
     async resolveFileData(requestId, dataItemId) {
         const files = this.dataTransferFiles.get(requestId);
         if (!files) {
-            throw ( new Error('No data transfer found'));
+            throw ( new Error("No data transfer found"));
         }
         const file = files.find(file => file.id === dataItemId);
         if (!file) {
-            throw ( new Error('No matching file found in data transfer'));
+            throw ( new Error("No matching file found in data transfer"));
         }
         return VSBuffer.wrap(await file.data());
     }

package/vscode/src/vs/workbench/contrib/customEditor/common/customTextEditorModel.js

@@ -14,13 +14,20 @@ import { ITextFileService } from '@codingame/monaco-vscode-api/vscode/vs/workben
 var CustomTextEditorModel_1;
 let CustomTextEditorModel = CustomTextEditorModel_1 = class CustomTextEditorModel extends Disposable {
     static async create(instantiationService, viewType, resource) {
-        return instantiationService.invokeFunction(async (accessor) => {
+        return instantiationService.invokeFunction(async accessor => {
             const textModelResolverService = accessor.get(ITextModelService);
             const model = await textModelResolverService.createModelReference(resource);
             return instantiationService.createInstance(CustomTextEditorModel_1, viewType, resource, model);
         });
     }
-    constructor(viewType, _resource, _model, textFileService, _labelService, extensionService) {
+    constructor(
+        viewType,
+        _resource,
+        _model,
+        textFileService,
+        _labelService,
+        extensionService
+    ) {
         super();
         this.viewType = viewType;
         this._resource = _resource;
@@ -38,8 +45,12 @@ let CustomTextEditorModel = CustomTextEditorModel_1 = class CustomTextEditorMode
         this._register(_model);
         this._textFileModel = this.textFileService.files.get(_resource);
         if (this._textFileModel) {
-            this._register(this._textFileModel.onDidChangeOrphaned(() => this._onDidChangeOrphaned.fire()));
-            this._register(this._textFileModel.onDidChangeReadonly(() => this._onDidChangeReadonly.fire()));
+            this._register(
+                this._textFileModel.onDidChangeOrphaned(() => this._onDidChangeOrphaned.fire())
+            );
+            this._register(
+                this._textFileModel.onDidChangeReadonly(() => this._onDidChangeReadonly.fire())
+            );
         }
         this._register(this.textFileService.files.onDidChangeDirty(e => {
             if (isEqual(this.resource, e.resource)) {
@@ -49,7 +60,7 @@ let CustomTextEditorModel = CustomTextEditorModel_1 = class CustomTextEditorMode
         }));
         this._register(extensionService.onWillStop(e => {
             e.veto(true, ( localize(
-                6431,
+                6741,
                 "An extension provided text editor for '{0}' is still open that would close otherwise.",
                 this.name
             )));
@@ -86,10 +97,6 @@ let CustomTextEditorModel = CustomTextEditorModel_1 = class CustomTextEditorMode
         return !!(await this.textFileService.saveAs(resource, targetResource, options));
     }
 };
-CustomTextEditorModel = CustomTextEditorModel_1 = ( __decorate([
-    ( __param(3, ITextFileService)),
-    ( __param(4, ILabelService)),
-    ( __param(5, IExtensionService))
-], CustomTextEditorModel));
+CustomTextEditorModel = CustomTextEditorModel_1 = ( __decorate([( __param(3, ITextFileService)), ( __param(4, ILabelService)), ( __param(5, IExtensionService))], CustomTextEditorModel));
 
 export { CustomTextEditorModel };

package/vscode/src/vs/workbench/contrib/externalUriOpener/common/contributedOpeners.js

@@ -9,8 +9,12 @@ import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbe
 
 var ContributedExternalUriOpenersStore_1;
 let ContributedExternalUriOpenersStore = class ContributedExternalUriOpenersStore extends Disposable {
-    static { ContributedExternalUriOpenersStore_1 = this; }
-    static { this.STORAGE_ID = 'externalUriOpeners'; }
+    static {
+        ContributedExternalUriOpenersStore_1 = this;
+    }
+    static {
+        this.STORAGE_ID = "externalUriOpeners";
+    }
     constructor(storageService, _extensionService) {
         super();
         this._extensionService = _extensionService;
@@ -19,12 +23,18 @@ let ContributedExternalUriOpenersStore = class ContributedExternalUriOpenersStor
         this._mementoObject = this._memento.getMemento(StorageScope.PROFILE, StorageTarget.MACHINE);
         for (const [id, value] of Object.entries(this._mementoObject || {})) {
             if (value) {
-                this.add(id, value.extensionId, { isCurrentlyRegistered: false });
+                this.add(id, value.extensionId, {
+                    isCurrentlyRegistered: false
+                });
             }
         }
         this.invalidateOpenersOnExtensionsChanged();
-        this._register(this._extensionService.onDidChangeExtensions(() => this.invalidateOpenersOnExtensionsChanged()));
-        this._register(this._extensionService.onDidChangeExtensionsStatus(() => this.invalidateOpenersOnExtensionsChanged()));
+        this._register(
+            this._extensionService.onDidChangeExtensions(() => this.invalidateOpenersOnExtensionsChanged())
+        );
+        this._register(
+            this._extensionService.onDidChangeExtensionsStatus(() => this.invalidateOpenersOnExtensionsChanged())
+        );
     }
     didRegisterOpener(id, extensionId) {
         this.add(id, extensionId, {
@@ -63,8 +73,7 @@ let ContributedExternalUriOpenersStore = class ContributedExternalUriOpenersStor
                         this.delete(id);
                     }
                 }
-            }
-            else {
+            } else {
                 this.delete(id);
             }
         }
@@ -79,9 +88,6 @@ let ContributedExternalUriOpenersStore = class ContributedExternalUriOpenersStor
         updateContributedOpeners(ids, descriptions);
     }
 };
-ContributedExternalUriOpenersStore = ContributedExternalUriOpenersStore_1 = ( __decorate([
-    ( __param(0, IStorageService)),
-    ( __param(1, IExtensionService))
-], ContributedExternalUriOpenersStore));
+ContributedExternalUriOpenersStore = ContributedExternalUriOpenersStore_1 = ( __decorate([( __param(0, IStorageService)), ( __param(1, IExtensionService))], ContributedExternalUriOpenersStore));
 
 export { ContributedExternalUriOpenersStore };