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

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

@@ -29,7 +29,15 @@ import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platf
 import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
 
 class MainThreadAuthenticationProvider extends Disposable {
-    constructor(_proxy, id, label, supportsMultipleAccounts, authorizationServers, resourceServer, onDidChangeSessionsEmitter) {
+    constructor(
+        _proxy,
+        id,
+        label,
+        supportsMultipleAccounts,
+        authorizationServers,
+        resourceServer,
+        onDidChangeSessionsEmitter
+    ) {
         super();
         this._proxy = _proxy;
         this.id = id;
@@ -50,8 +58,24 @@ class MainThreadAuthenticationProvider extends Disposable {
     }
 }
 class MainThreadAuthenticationProviderWithChallenges extends MainThreadAuthenticationProvider {
-    constructor(proxy, id, label, supportsMultipleAccounts, authorizationServers, resourceServer, onDidChangeSessionsEmitter) {
-        super(proxy, id, label, supportsMultipleAccounts, authorizationServers, resourceServer, onDidChangeSessionsEmitter);
+    constructor(
+        proxy,
+        id,
+        label,
+        supportsMultipleAccounts,
+        authorizationServers,
+        resourceServer,
+        onDidChangeSessionsEmitter
+    ) {
+        super(
+            proxy,
+            id,
+            label,
+            supportsMultipleAccounts,
+            authorizationServers,
+            resourceServer,
+            onDidChangeSessionsEmitter
+        );
     }
     getSessionsFromChallenges(constraint, options) {
         return this._proxy.$getSessionsFromChallenges(this.id, constraint, options);
@@ -61,7 +85,24 @@ class MainThreadAuthenticationProviderWithChallenges extends MainThreadAuthentic
     }
 }
 let MainThreadAuthentication = class MainThreadAuthentication extends Disposable {
-    constructor(extHostContext, productService, authenticationService, authenticationExtensionsService, authenticationAccessService, authenticationUsageService, dialogService, notificationService, extensionService, telemetryService, openerService, logService, urlService, dynamicAuthProviderStorageService, clipboardService, quickInputService) {
+    constructor(
+        extHostContext,
+        productService,
+        authenticationService,
+        authenticationExtensionsService,
+        authenticationAccessService,
+        authenticationUsageService,
+        dialogService,
+        notificationService,
+        extensionService,
+        telemetryService,
+        openerService,
+        logService,
+        urlService,
+        dynamicAuthProviderStorageService,
+        clipboardService,
+        quickInputService
+    ) {
         super();
         this.productService = productService;
         this.authenticationService = authenticationService;
@@ -83,7 +124,9 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
         this._suppressUnregisterEvent = false;
         this._sentClientIdUsageEvents = ( new Set());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostAuthentication));
-        this._register(this.authenticationService.onDidChangeSessions(e => this._proxy.$onDidChangeAuthenticationSessions(e.providerId, e.label)));
+        this._register(
+            this.authenticationService.onDidChangeSessions(e => this._proxy.$onDidChangeAuthenticationSessions(e.providerId, e.label))
+        );
         this._register(this.authenticationService.onDidUnregisterAuthenticationProvider(e => {
             if (!this._suppressUnregisterEvent) {
                 this._proxy.$onDidUnregisterAuthenticationProvider(e.id);
@@ -106,24 +149,42 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
                 let initialTokens = undefined;
                 if (clientId) {
                     initialTokens = await this.dynamicAuthProviderStorageService.getSessionsForDynamicAuthProvider(authProviderId, clientId);
-                }
-                else if (serverMetadata.client_id_metadata_document_supported) {
+                } else if (serverMetadata.client_id_metadata_document_supported) {
                     clientId = this.productService.authClientIdMetadataUrl;
                 }
-                return await this._proxy.$registerDynamicAuthProvider(authorizationServer, serverMetadata, resource, clientId, clientSecret, initialTokens);
+                return await this._proxy.$registerDynamicAuthProvider(
+                    authorizationServer,
+                    serverMetadata,
+                    resource,
+                    clientId,
+                    clientSecret,
+                    initialTokens
+                );
             }
         }));
     }
-    async $registerAuthenticationProvider({ id, label, supportsMultipleAccounts, resourceServer, supportedAuthorizationServers, supportsChallenges }) {
+    async $registerAuthenticationProvider(
+        {
+            id,
+            label,
+            supportsMultipleAccounts,
+            resourceServer,
+            supportedAuthorizationServers,
+            supportsChallenges
+        }
+    ) {
         if (!this.authenticationService.declaredProviders.find(p => p.id === id)) {
-            this.logService.warn(`Authentication provider ${id} was not declared in the Extension Manifest.`);
-            this.telemetryService.publicLog2('authentication.providerNotDeclared', { id });
+            this.logService.warn(
+                `Authentication provider ${id} was not declared in the Extension Manifest.`
+            );
+            this.telemetryService.publicLog2("authentication.providerNotDeclared", {
+                id
+            });
         }
         const emitter = ( new Emitter());
         this._registrations.set(id, emitter);
         const supportedAuthorizationServerUris = ( (supportedAuthorizationServers ?? []).map(i => URI.revive(i)));
-        const provider = supportsChallenges
-            ? ( new MainThreadAuthenticationProviderWithChallenges(
+        const provider = supportsChallenges ? ( new MainThreadAuthenticationProviderWithChallenges(
             this._proxy,
             id,
             label,
@@ -131,8 +192,7 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
             supportedAuthorizationServerUris,
             resourceServer ? URI.revive(resourceServer) : undefined,
             emitter
-        ))
-            : ( new MainThreadAuthenticationProvider(
+        )) : ( new MainThreadAuthenticationProvider(
             this._proxy,
             id,
             label,
@@ -148,8 +208,7 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
         this._suppressUnregisterEvent = true;
         try {
             this.authenticationService.unregisterAuthenticationProvider(id);
-        }
-        finally {
+        } finally {
             this._suppressUnregisterEvent = false;
         }
     }
@@ -170,7 +229,7 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
     async $waitForUriHandler(expectedUri) {
         const deferredPromise = ( new DeferredPromise());
         const disposable = this.urlService.registerHandler({
-            handleURL: async (uri) => {
+            handleURL: async uri => {
                 if (uri.scheme !== expectedUri.scheme || uri.authority !== expectedUri.authority || uri.path !== expectedUri.path) {
                     return false;
                 }
@@ -181,22 +240,22 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
         });
         const result = await raceTimeout(deferredPromise.p, 5 * 60 * 1000);
         if (!result) {
-            throw ( new Error('Timed out waiting for URI handler'));
+            throw ( new Error("Timed out waiting for URI handler"));
         }
         return await deferredPromise.p;
     }
     $showContinueNotification(message) {
-        const yes = ( localize(2472, "Yes"));
-        const no = ( localize(2473, "No"));
+        const yes = ( localize(2475, "Yes"));
+        const no = ( localize(2476, "No"));
         const deferredPromise = ( new DeferredPromise());
         let result = false;
         const handle = this.notificationService.prompt(Severity.Warning, message, [{
-                label: yes,
-                run: () => result = true
-            }, {
-                label: no,
-                run: () => result = false
-            }]);
+            label: yes,
+            run: () => result = true
+        }, {
+            label: no,
+            run: () => result = false
+        }]);
         const disposable = handle.onDidClose(() => {
             deferredPromise.complete(result);
             disposable.dispose();
@@ -209,15 +268,25 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
             label: details.label,
             supportsMultipleAccounts: true,
             supportedAuthorizationServers: [details.authorizationServer],
-            resourceServer: details.resourceServer,
+            resourceServer: details.resourceServer
         });
         await this.dynamicAuthProviderStorageService.storeClientRegistration(details.id, ( URI.revive(details.authorizationServer).toString(true)), details.clientId, details.clientSecret, details.label);
     }
     async $setSessionsForDynamicAuthProvider(authProviderId, clientId, sessions) {
         await this.dynamicAuthProviderStorageService.setSessionsForDynamicAuthProvider(authProviderId, clientId, sessions);
     }
-    async $sendDidChangeDynamicProviderInfo({ providerId, clientId, authorizationServer, label, clientSecret }) {
-        this.logService.info(`Client ID for authentication provider ${providerId} changed to ${clientId}`);
+    async $sendDidChangeDynamicProviderInfo(
+        {
+            providerId,
+            clientId,
+            authorizationServer,
+            label,
+            clientSecret
+        }
+    ) {
+        this.logService.info(
+            `Client ID for authentication provider ${providerId} changed to ${clientId}`
+        );
         const existing = this.dynamicAuthProviderStorageService.getInteractedProviders().find(p => p.providerId === providerId);
         if (!existing) {
             throw ( new Error(
@@ -231,70 +300,66 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
         const customMessage = provider.confirmation?.(extensionName, recreatingSession);
         if (customMessage) {
             message = customMessage;
-        }
-        else {
-            message = recreatingSession
-                ? ( localize(
-                2474,
+        } else {
+            message = recreatingSession ? ( localize(
+                2477,
                 "The extension '{0}' wants you to sign in again using {1}.",
                 extensionName,
                 provider.label
-            ))
-                : ( localize(
-                2475,
+            )) : ( localize(
+                2478,
                 "The extension '{0}' wants to sign in using {1}.",
                 extensionName,
                 provider.label
             ));
         }
-        const buttons = [
-            {
-                label: ( localize(2476, "&&Allow")),
-                run() {
-                    return true;
-                },
+        const buttons = [{
+            label: ( localize(2479, "&&Allow")),
+            run() {
+                return true;
             }
-        ];
+        }];
         if (options?.learnMore) {
             buttons.push({
-                label: ( localize(2477, "Learn more")),
+                label: ( localize(2480, "Learn more")),
                 run: async () => {
                     const result = this.loginPrompt(provider, extensionName, recreatingSession, options);
-                    await this.openerService.open(URI.revive(options.learnMore), { allowCommands: true });
+                    await this.openerService.open(URI.revive(options.learnMore), {
+                        allowCommands: true
+                    });
                     return await result;
                 }
             });
         }
-        const { result } = await this.dialogService.prompt({
+        const {
+            result
+        } = await this.dialogService.prompt({
             type: Severity.Info,
             message,
             buttons,
             detail: options?.detail,
-            cancelButton: true,
+            cancelButton: true
         });
         return result ?? false;
     }
     async continueWithIncorrectAccountPrompt(chosenAccountLabel, requestedAccountLabel) {
         const result = await this.dialogService.prompt({
-            message: ( localize(2478, "Incorrect account detected")),
+            message: ( localize(2481, "Incorrect account detected")),
             detail: ( localize(
-                2479,
+                2482,
                 "The chosen account, {0}, does not match the requested account, {1}.",
                 chosenAccountLabel,
                 requestedAccountLabel
             )),
             type: Severity.Warning,
             cancelButton: true,
-            buttons: [
-                {
-                    label: ( localize(2480, 'Keep {0}', chosenAccountLabel)),
-                    run: () => chosenAccountLabel
-                },
-                {
-                    label: ( localize(2481, 'Login with {0}', requestedAccountLabel)),
-                    run: () => requestedAccountLabel
-                }
-            ],
+            buttons: [{
+                label: ( localize(2483, "Keep {0}", chosenAccountLabel)),
+                run: () => chosenAccountLabel
+            }, {
+                label: ( localize(2484, "Login with {0}", requestedAccountLabel)),
+                run: () => requestedAccountLabel
+            }]
         });
         if (!result.result) {
             throw ( new CancellationError());
@@ -303,30 +368,31 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
     }
     async doGetSession(providerId, scopeListOrRequest, extensionId, extensionName, options) {
         const authorizationServer = URI.revive(options.authorizationServer);
-        const sessions = await this.authenticationService.getSessions(providerId, scopeListOrRequest, { account: options.account, authorizationServer }, true);
+        const sessions = await this.authenticationService.getSessions(providerId, scopeListOrRequest, {
+            account: options.account,
+            authorizationServer
+        }, true);
         const provider = this.authenticationService.getProvider(providerId);
         if (options.forceNewSession && options.createIfNone) {
             throw ( new Error(
-                'Invalid combination of options. Please remove one of the following: forceNewSession, createIfNone'
+                "Invalid combination of options. Please remove one of the following: forceNewSession, createIfNone"
             ));
         }
         if (options.forceNewSession && options.silent) {
             throw ( new Error(
-                'Invalid combination of options. Please remove one of the following: forceNewSession, silent'
+                "Invalid combination of options. Please remove one of the following: forceNewSession, silent"
             ));
         }
         if (options.createIfNone && options.silent) {
             throw ( new Error(
-                'Invalid combination of options. Please remove one of the following: createIfNone, silent'
+                "Invalid combination of options. Please remove one of the following: createIfNone, silent"
             ));
         }
         if (options.clearSessionPreference) {
             this.authenticationExtensionsService.removeAccountPreference(extensionId, providerId);
         }
         const matchingAccountPreferenceSession =
-        options.account
-            ? sessions[0]
-            : this._getAccountPreference(extensionId, providerId, sessions);
+        options.account ? sessions[0] : this._getAccountPreference(extensionId, providerId, sessions);
         if (!options.forceNewSession && sessions.length) {
             if (matchingAccountPreferenceSession && this.authenticationAccessService.isAccessAllowed(providerId, matchingAccountPreferenceSession.account.label, extensionId)) {
                 return matchingAccountPreferenceSession;
@@ -337,24 +403,20 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
         }
         if (options.createIfNone || options.forceNewSession) {
             let uiOptions;
-            if (typeof options.forceNewSession === 'object') {
+            if (typeof options.forceNewSession === "object") {
                 uiOptions = options.forceNewSession;
-            }
-            else if (typeof options.createIfNone === 'object') {
+            } else if (typeof options.createIfNone === "object") {
                 uiOptions = options.createIfNone;
             }
             const recreatingSession = !!(options.forceNewSession && sessions.length);
             const isAllowed = await this.loginPrompt(provider, extensionName, recreatingSession, uiOptions);
             if (!isAllowed) {
-                throw ( new Error('User did not consent to login.'));
+                throw ( new Error("User did not consent to login."));
             }
             let session;
             if (sessions?.length && !options.forceNewSession) {
-                session = provider.supportsMultipleAccounts && !options.account
-                    ? await this.authenticationExtensionsService.selectSession(providerId, extensionId, extensionName, scopeListOrRequest, sessions)
-                    : sessions[0];
-            }
-            else {
+                session = provider.supportsMultipleAccounts && !options.account ? await this.authenticationExtensionsService.selectSession(providerId, extensionId, extensionName, scopeListOrRequest, sessions) : sessions[0];
+            } else {
                 const accountToCreate = options.account ?? matchingAccountPreferenceSession?.account;
                 do {
                     session = await this.authenticationService.createSession(providerId, scopeListOrRequest, {
@@ -362,25 +424,27 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
                         account: accountToCreate,
                         authorizationServer
                     });
-                } while (accountToCreate
-                    && accountToCreate.label !== session.account.label
-                    && !(await this.continueWithIncorrectAccountPrompt(session.account.label, accountToCreate.label)));
+                } while (accountToCreate && accountToCreate.label !== session.account.label && !(await this.continueWithIncorrectAccountPrompt(session.account.label, accountToCreate.label)));
             }
-            this.authenticationAccessService.updateAllowedExtensions(providerId, session.account.label, [{ id: extensionId, name: extensionName, allowed: true }]);
+            this.authenticationAccessService.updateAllowedExtensions(providerId, session.account.label, [{
+                id: extensionId,
+                name: extensionName,
+                allowed: true
+            }]);
             this.authenticationExtensionsService.updateNewSessionRequests(providerId, [session]);
             this.authenticationExtensionsService.updateAccountPreference(extensionId, providerId, session.account);
             return session;
         }
         if (!matchingAccountPreferenceSession) {
-            const validSessions = sessions.filter(session => this.authenticationAccessService.isAccessAllowed(providerId, session.account.label, extensionId));
+            const validSessions = sessions.filter(
+                session => this.authenticationAccessService.isAccessAllowed(providerId, session.account.label, extensionId)
+            );
             if (validSessions.length === 1) {
                 return validSessions[0];
             }
         }
         if (!options.silent) {
-            sessions.length
-                ? this.authenticationExtensionsService.requestSessionAccess(providerId, extensionId, extensionName, scopeListOrRequest, sessions)
-                : await this.authenticationExtensionsService.requestNewSession(providerId, scopeListOrRequest, extensionId, extensionName);
+            sessions.length ? this.authenticationExtensionsService.requestSessionAccess(providerId, extensionId, extensionName, scopeListOrRequest, sessions) : await this.authenticationExtensionsService.requestNewSession(providerId, scopeListOrRequest, extensionId, extensionName);
         }
         return undefined;
     }
@@ -392,7 +456,13 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
         const session = await this.doGetSession(providerId, scopeListOrRequest, extensionId, extensionName, options);
         if (session) {
             this.sendProviderUsageTelemetry(extensionId, providerId);
-            this.authenticationUsageService.addAccountUsage(providerId, session.account.label, session.scopes, extensionId, extensionName);
+            this.authenticationUsageService.addAccountUsage(
+                providerId,
+                session.account.label,
+                session.scopes,
+                extensionId,
+                extensionName
+            );
         }
         return session;
     }
@@ -401,14 +471,16 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
         return accounts;
     }
     sendClientIdUsageTelemetry(extensionId, providerId, scopes) {
-        const containsVSCodeClientIdScope = ( scopes.some(scope => scope.startsWith('VSCODE_CLIENT_ID:')));
+        const containsVSCodeClientIdScope = ( scopes.some(scope => scope.startsWith("VSCODE_CLIENT_ID:")));
         const key = `${extensionId}|${providerId}|${containsVSCodeClientIdScope}`;
         if (( this._sentClientIdUsageEvents.has(key))) {
             return;
         }
         this._sentClientIdUsageEvents.add(key);
         if (containsVSCodeClientIdScope) {
-            this.telemetryService.publicLog2('authentication.clientIdUsage', { extensionId });
+            this.telemetryService.publicLog2("authentication.clientIdUsage", {
+                extensionId
+            });
         }
     }
     sendProviderUsageTelemetry(extensionId, providerId) {
@@ -417,7 +489,10 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
             return;
         }
         this._sentProviderUsageEvents.add(key);
-        this.telemetryService.publicLog2('authentication.providerUsage', { providerId, extensionId });
+        this.telemetryService.publicLog2("authentication.providerUsage", {
+            providerId,
+            extensionId
+        });
     }
     _getAccountPreference(extensionId, providerId, sessions) {
         if (sessions.length === 0) {
@@ -431,79 +506,75 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
         return undefined;
     }
     async $showDeviceCodeModal(userCode, verificationUri) {
-        const { result } = await this.dialogService.prompt({
+        const {
+            result
+        } = await this.dialogService.prompt({
             type: Severity.Info,
-            message: ( localize(2482, "Device Code Authentication")),
+            message: ( localize(2485, "Device Code Authentication")),
             detail: ( localize(
-                2483,
+                2486,
                 "Your code: {0}\n\nTo complete authentication, navigate to {1} and enter the code above.",
                 userCode,
                 verificationUri
             )),
-            buttons: [
-                {
-                    label: ( localize(2484, "Copy & Continue")),
-                    run: () => true
-                }
-            ],
+            buttons: [{
+                label: ( localize(2487, "Copy & Continue")),
+                run: () => true
+            }],
             cancelButton: true
         });
         if (result) {
             try {
                 await this.clipboardService.writeText(userCode);
                 return await this.openerService.open(( URI.parse(verificationUri)));
-            }
-            catch (error) {
-                this.notificationService.error(( localize(2485, "Failed to open {0}", verificationUri)));
+            } catch (error) {
+                this.notificationService.error(( localize(2488, "Failed to open {0}", verificationUri)));
             }
         }
         return false;
     }
     async $promptForClientRegistration(authorizationServerUrl) {
-        const redirectUrls = 'http://127.0.0.1:33418\nhttps://vscode.dev/redirect';
+        const redirectUrls = "http://127.0.0.1:33418\nhttps://vscode.dev/redirect";
         const result = await this.dialogService.prompt({
             type: Severity.Info,
-            message: ( localize(2486, "Dynamic Client Registration not supported")),
+            message: ( localize(2489, "Dynamic Client Registration not supported")),
             detail: ( localize(
-                2487,
+                2490,
                 "The authorization server '{0}' does not support automatic client registration. Do you want to proceed by manually providing a client registration (client ID)?\n\nNote: When registering your OAuth application, make sure to include these redirect URIs:\n{1}",
                 authorizationServerUrl,
                 redirectUrls
             )),
-            buttons: [
-                {
-                    label: ( localize(2488, "Copy URIs & Proceed")),
-                    run: async () => {
-                        try {
-                            await this.clipboardService.writeText(redirectUrls);
-                        }
-                        catch (error) {
-                            this.notificationService.error(( localize(2489, "Failed to copy redirect URIs to clipboard.")));
-                        }
-                        return true;
+            buttons: [{
+                label: ( localize(2491, "Copy URIs & Proceed")),
+                run: async () => {
+                    try {
+                        await this.clipboardService.writeText(redirectUrls);
+                    } catch (error) {
+                        this.notificationService.error(( localize(2492, "Failed to copy redirect URIs to clipboard.")));
                     }
-                },
-            ],
+                    return true;
+                }
+            }],
             cancelButton: {
-                label: ( localize(2490, "Cancel")),
+                label: ( localize(2493, "Cancel")),
                 run: () => false
             }
         });
         if (!result) {
             return undefined;
         }
-        const sharedTitle = ( localize(2491, "Add Client Registration Details"));
+        const sharedTitle = ( localize(2494, "Add Client Registration Details"));
         const clientId = await this.quickInputService.input({
             title: sharedTitle,
             prompt: ( localize(
-                2492,
+                2495,
                 "Enter an existing client ID that has been registered with the following redirect URIs: http://127.0.0.1:33418, https://vscode.dev/redirect"
             )),
-            placeHolder: ( localize(2493, "OAuth client ID (azye39d...)")),
+            placeHolder: ( localize(2496, "OAuth client ID (azye39d...)")),
             ignoreFocusLost: true,
-            validateInput: async (value) => {
+            validateInput: async value => {
                 if (!value || value.trim().length === 0) {
-                    return localize(2494, "Client ID is required");
+                    return localize(2497, "Client ID is required");
                 }
                 return undefined;
             }
@@ -514,11 +585,11 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
         const clientSecret = await this.quickInputService.input({
             title: sharedTitle,
             prompt: ( localize(
-                2495,
+                2498,
                 "(optional) Enter an existing client secret associated with the client id '{0}' or leave this field blank",
                 clientId
             )),
-            placeHolder: ( localize(2496, "OAuth client secret (wer32o50f...) or leave it blank")),
+            placeHolder: ( localize(2499, "OAuth client secret (wer32o50f...) or leave it blank")),
             password: true,
             ignoreFocusLost: true
         });
@@ -528,23 +599,9 @@ let MainThreadAuthentication = class MainThreadAuthentication extends Disposable
         };
     }
 };
-MainThreadAuthentication = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadAuthentication),
-    ( __param(1, IProductService)),
-    ( __param(2, IAuthenticationService)),
-    ( __param(3, IAuthenticationExtensionsService)),
-    ( __param(4, IAuthenticationAccessService)),
-    ( __param(5, IAuthenticationUsageService)),
-    ( __param(6, IDialogService)),
-    ( __param(7, INotificationService)),
-    ( __param(8, IExtensionService)),
-    ( __param(9, ITelemetryService)),
-    ( __param(10, IOpenerService)),
-    ( __param(11, ILogService)),
-    ( __param(12, IURLService)),
-    ( __param(13, IDynamicAuthenticationProviderStorageService)),
-    ( __param(14, IClipboardService)),
-    ( __param(15, IQuickInputService))
-], MainThreadAuthentication);
+MainThreadAuthentication = __decorate(
+    [extHostNamedCustomer(MainContext.MainThreadAuthentication), ( __param(1, IProductService)), ( __param(2, IAuthenticationService)), ( __param(3, IAuthenticationExtensionsService)), ( __param(4, IAuthenticationAccessService)), ( __param(5, IAuthenticationUsageService)), ( __param(6, IDialogService)), ( __param(7, INotificationService)), ( __param(8, IExtensionService)), ( __param(9, ITelemetryService)), ( __param(10, IOpenerService)), ( __param(11, ILogService)), ( __param(12, IURLService)), ( __param(13, IDynamicAuthenticationProviderStorageService)), ( __param(14, IClipboardService)), ( __param(15, IQuickInputService))],
+    MainThreadAuthentication
+);
 
 export { MainThreadAuthentication };

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

@@ -17,21 +17,19 @@ let MainThreadBulkEdits = class MainThreadBulkEdits {
         this._logService = _logService;
         this._uriIdentService = _uriIdentService;
     }
-    dispose() { }
+    dispose() {}
     $tryApplyWorkspaceEdit(dto, undoRedoGroupId, isRefactoring) {
         const edits = reviveWorkspaceEditDto(dto.value, this._uriIdentService);
-        return this._bulkEditService.apply(edits, { undoRedoGroupId, respectAutoSaveConfig: isRefactoring }).then((res) => res.isApplied, err => {
+        return this._bulkEditService.apply(edits, {
+            undoRedoGroupId,
+            respectAutoSaveConfig: isRefactoring
+        }).then(res => res.isApplied, err => {
             this._logService.warn(`IGNORING workspace edit: ${err}`);
             return false;
         });
     }
 };
-MainThreadBulkEdits = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadBulkEdits),
-    ( __param(1, IBulkEditService)),
-    ( __param(2, ILogService)),
-    ( __param(3, IUriIdentityService))
-], MainThreadBulkEdits);
+MainThreadBulkEdits = __decorate([extHostNamedCustomer(MainContext.MainThreadBulkEdits), ( __param(1, IBulkEditService)), ( __param(2, ILogService)), ( __param(3, IUriIdentityService))], MainThreadBulkEdits);
 function reviveWorkspaceEditDto(data, uriIdentityService, resolveDataTransferFile) {
     if (!data || !data.edits) {
         return data;
@@ -45,15 +43,13 @@ function reviveWorkspaceEditDto(data, uriIdentityService, resolveDataTransferFil
             if (edit.options) {
                 const inContents = edit.options?.contents;
                 if (inContents) {
-                    if (inContents.type === 'base64') {
+                    if (inContents.type === "base64") {
                         edit.options.contents = Promise.resolve(decodeBase64(inContents.value));
-                    }
-                    else {
+                    } else {
                         if (resolveDataTransferFile) {
                             edit.options.contents = resolveDataTransferFile(inContents.id);
-                        }
-                        else {
-                            throw ( new Error('Could not revive data transfer file'));
+                        } else {
+                            throw ( new Error("Could not revive data transfer file"));
                         }
                     }
                 }