@codingame/monaco-vscode-api 1.83.15 → 1.85.0-next.0

package/vscode/src/vs/workbench/contrib/testing/common/testingContinuousRunService.js

@@ -0,0 +1,102 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { StoredValue } from './storedValue.js';
+import { TestingContextKeys } from './testingContextKeys.js';
+import { ITestService } from './testService.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { TestId } from './testId.js';
+import { WellDefinedPrefixTree } from '../../../../base/common/prefixTree.js';
+const ITestingContinuousRunService = ( createDecorator('testingContinuousRunService'));
+let TestingContinuousRunService = class TestingContinuousRunService extends Disposable {
+    get lastRunProfileIds() {
+        return this.lastRun.get(( new Set()));
+    }
+    constructor(testService, storageService, contextKeyService) {
+        super();
+        this.testService = testService;
+        this.changeEmitter = ( new Emitter());
+        this.running = ( new WellDefinedPrefixTree());
+        this.onDidChange = this.changeEmitter.event;
+        this.isGloballyOn = TestingContextKeys.isContinuousModeOn.bindTo(contextKeyService);
+        this.lastRun = this._register(( new StoredValue({
+            key: 'lastContinuousRunProfileIds',
+            scope: 1 ,
+            target: 1 ,
+            serialization: {
+                deserialize: v => ( new Set(JSON.parse(v))),
+                serialize: v => JSON.stringify([...v])
+            },
+        }, storageService)));
+        this._register(toDisposable(() => {
+            this.globallyRunning?.dispose();
+            for (const cts of ( this.running.values())) {
+                cts.dispose();
+            }
+        }));
+    }
+    isSpecificallyEnabledFor(testId) {
+        return this.running.size > 0 && this.running.hasKey(TestId.fromString(testId).path);
+    }
+    isEnabledForAParentOf(testId) {
+        if (this.globallyRunning) {
+            return true;
+        }
+        return this.running.size > 0 && this.running.hasKeyOrParent(TestId.fromString(testId).path);
+    }
+    isEnabledForAChildOf(testId) {
+        return this.running.size > 0 && this.running.hasKeyOrChildren(TestId.fromString(testId).path);
+    }
+    isEnabled() {
+        return !!this.globallyRunning || this.running.size > 0;
+    }
+    start(profile, testId) {
+        const cts = ( new CancellationTokenSource());
+        if (testId === undefined) {
+            this.isGloballyOn.set(true);
+        }
+        if (!testId) {
+            this.globallyRunning?.dispose(true);
+            this.globallyRunning = cts;
+        }
+        else {
+            this.running.mutate(TestId.fromString(testId).path, c => {
+                c?.dispose(true);
+                return cts;
+            });
+        }
+        this.lastRun.store(( new Set(( profile.map(p => p.profileId)))));
+        this.testService.startContinuousRun({
+            continuous: true,
+            targets: ( profile.map(p => ({
+                testIds: [testId ?? p.controllerId],
+                controllerId: p.controllerId,
+                profileGroup: p.group,
+                profileId: p.profileId
+            }))),
+        }, cts.token);
+        this.changeEmitter.fire(testId);
+    }
+    stop(testId) {
+        if (!testId) {
+            this.globallyRunning?.dispose(true);
+            this.globallyRunning = undefined;
+        }
+        else {
+            this.running.delete(TestId.fromString(testId).path)?.dispose(true);
+        }
+        if (testId === undefined) {
+            this.isGloballyOn.set(false);
+        }
+        this.changeEmitter.fire(testId);
+    }
+};
+TestingContinuousRunService = ( __decorate([
+    ( __param(0, ITestService)),
+    ( __param(1, IStorageService)),
+    ( __param(2, IContextKeyService))
+], TestingContinuousRunService));
+export { ITestingContinuousRunService, TestingContinuousRunService };

package/vscode/src/vs/workbench/contrib/testing/common/testingDecorations.js

@@ -0,0 +1,29 @@
+import { binarySearch } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+class TestDecorations {
+    constructor() {
+        this.value = [];
+    }
+    push(value) {
+        const searchIndex = binarySearch(this.value, value, (a, b) => a.line - b.line);
+        this.value.splice(searchIndex < 0 ? ~searchIndex : searchIndex, 0, value);
+    }
+    *lines() {
+        if (!this.value.length) {
+            return;
+        }
+        let startIndex = 0;
+        let startLine = this.value[0].line;
+        for (let i = 1; i < this.value.length; i++) {
+            const v = this.value[i];
+            if (v.line !== startLine) {
+                yield [startLine, this.value.slice(startIndex, i)];
+                startLine = v.line;
+                startIndex = i;
+            }
+        }
+        yield [startLine, this.value.slice(startIndex)];
+    }
+}
+const ITestingDecorationsService = ( createDecorator('testingDecorationService'));
+export { ITestingDecorationsService, TestDecorations };

package/vscode/src/vs/workbench/{services/editor/browser/editorDropService.js → contrib/testing/common/testingPeekOpener.js}

@@ -1,3 +1,3 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-const IEditorDropService = ( createDecorator('editorDropService'));
-export { IEditorDropService };
+const ITestingPeekOpener = ( createDecorator('testingPeekOpener'));
+export { ITestingPeekOpener };

package/vscode/src/vs/workbench/contrib/testing/common/testingStates.js

@@ -0,0 +1,47 @@
+const statePriority = {
+    [2 ]: 6,
+    [6 ]: 5,
+    [4 ]: 4,
+    [1 ]: 3,
+    [3 ]: 2,
+    [0 ]: 0,
+    [5 ]: 1,
+};
+const isFailedState = (s) => s === 6  || s === 4 ;
+const isStateWithResult = (s) => s === 6  || s === 4  || s === 3 ;
+Object.entries(statePriority).reduce((acc, [stateStr, priority]) => {
+    const state = Number(stateStr);
+    acc[state] = { statusNode: true, state, priority };
+    return acc;
+}, {});
+const cmpPriority = (a, b) => statePriority[b] - statePriority[a];
+const maxPriority = (...states) => {
+    switch (states.length) {
+        case 0:
+            return 0 ;
+        case 1:
+            return states[0];
+        case 2:
+            return statePriority[states[0]] > statePriority[states[1]] ? states[0] : states[1];
+        default: {
+            let max = states[0];
+            for (let i = 1; i < states.length; i++) {
+                if (statePriority[max] < statePriority[states[i]]) {
+                    max = states[i];
+                }
+            }
+            return max;
+        }
+    }
+};
+const statesInOrder = ( ( Object.keys(statePriority)).map(s => Number(s))).sort(cmpPriority);
+const terminalStatePriorities = {
+    [3 ]: 0,
+    [5 ]: 1,
+    [4 ]: 2,
+    [6 ]: 3,
+};
+const makeEmptyCounts = () => {
+    return ( new Uint32Array(statesInOrder.length));
+};
+export { cmpPriority, isFailedState, isStateWithResult, makeEmptyCounts, maxPriority, statePriority, statesInOrder, terminalStatePriorities };

package/vscode/src/vs/workbench/contrib/webview/browser/webviewWindowDragMonitor.js

@@ -1,16 +1,17 @@
 import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { $window } from 'monaco-editor/esm/vs/base/browser/window.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 class WebviewWindowDragMonitor extends Disposable {
     constructor(getWebview) {
         super();
-        this._register(dom.addDisposableListener(window, dom.EventType.DRAG_START, () => {
+        this._register(dom.addDisposableListener($window, dom.EventType.DRAG_START, () => {
             getWebview()?.windowDidDragStart();
         }));
         const onDragEnd = () => {
             getWebview()?.windowDidDragEnd();
         };
-        this._register(dom.addDisposableListener(window, dom.EventType.DRAG_END, onDragEnd));
-        this._register(dom.addDisposableListener(window, dom.EventType.MOUSE_MOVE, currentEvent => {
+        this._register(dom.addDisposableListener($window, dom.EventType.DRAG_END, onDragEnd));
+        this._register(dom.addDisposableListener($window, dom.EventType.MOUSE_MOVE, currentEvent => {
             if (currentEvent.buttons === 0) {
                 onDragEnd();
             }

package/vscode/src/vs/workbench/contrib/webviewPanel/browser/webviewEditor.js

@@ -1,5 +1,6 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { $window } from 'monaco-editor/esm/vs/base/browser/window.js';
 import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { DisposableStore, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
@@ -12,7 +13,6 @@ import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeS
 import { EditorPane } from '../../../browser/parts/editor/editorPane.js';
 import { WebviewWindowDragMonitor } from '../../webview/browser/webviewWindowDragMonitor.js';
 import { WebviewInput } from './webviewEditorInput.js';
-import { IEditorDropService } from '../../../services/editor/browser/editorDropService.js';
 import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
 import { IEditorService } from '../../../services/editor/common/editorService.js';
 import { IHostService } from '../../../services/host/browser/host.js';
@@ -30,11 +30,11 @@ let WebviewEditor = class WebviewEditor extends EditorPane {
     static { WebviewEditor_1 = this; }
     static { this.ID = 'WebviewEditor'; }
     get onDidFocus() { return this._onDidFocusWebview.event; }
-    constructor(telemetryService, themeService, storageService, editorGroupsService, _editorService, _workbenchLayoutService, _editorDropService, _hostService, _contextKeyService) {
+    constructor(telemetryService, themeService, storageService, _editorGroupsService, _editorService, _workbenchLayoutService, _hostService, _contextKeyService) {
         super(WebviewEditor_1.ID, telemetryService, themeService, storageService);
+        this._editorGroupsService = _editorGroupsService;
         this._editorService = _editorService;
         this._workbenchLayoutService = _workbenchLayoutService;
-        this._editorDropService = _editorDropService;
         this._hostService = _hostService;
         this._contextKeyService = _contextKeyService;
         this._visible = false;
@@ -43,7 +43,7 @@ let WebviewEditor = class WebviewEditor extends EditorPane {
         this._onFocusWindowHandler = this._register(( new MutableDisposable()));
         this._onDidFocusWebview = this._register(( new Emitter()));
         this._scopedContextKeyService = this._register(( new MutableDisposable()));
-        this._register(Event.any(editorGroupsService.onDidScroll, editorGroupsService.onDidAddGroup, editorGroupsService.onDidRemoveGroup, editorGroupsService.onDidMoveGroup)(() => {
+        this._register(Event.any(_editorGroupsService.activePart.onDidScroll, _editorGroupsService.activePart.onDidAddGroup, _editorGroupsService.activePart.onDidRemoveGroup, _editorGroupsService.activePart.onDidMoveGroup)(() => {
             if (this.webview && this._visible) {
                 this.synchronizeWebviewContainerDimensions(this.webview);
             }
@@ -136,7 +136,7 @@ let WebviewEditor = class WebviewEditor extends EditorPane {
             dom.setParentFlowTo(input.webview.container, this._element);
         }
         this._webviewVisibleDisposables.clear();
-        this._webviewVisibleDisposables.add(this._editorDropService.createEditorDropTarget(input.webview.container, {
+        this._webviewVisibleDisposables.add(this._editorGroupsService.createEditorDropTarget(input.webview.container, {
             containsGroup: (group) => this.group?.id === group.id
         }));
         this._webviewVisibleDisposables.add(( new WebviewWindowDragMonitor(() => this.webview)));
@@ -147,7 +147,7 @@ let WebviewEditor = class WebviewEditor extends EditorPane {
         if (!this._element?.isConnected) {
             return;
         }
-        const rootContainer = this._workbenchLayoutService.getContainer("workbench.parts.editor" );
+        const rootContainer = this._workbenchLayoutService.getContainer($window, "workbench.parts.editor" );
         webview.layoutWebviewOverElement(this._element.parentElement, dimension, rootContainer);
     }
     trackFocus(webview) {
@@ -166,8 +166,7 @@ WebviewEditor = WebviewEditor_1 = ( __decorate([
     ( __param(3, IEditorGroupsService)),
     ( __param(4, IEditorService)),
     ( __param(5, IWorkbenchLayoutService)),
-    ( __param(6, IEditorDropService)),
-    ( __param(7, IHostService)),
-    ( __param(8, IContextKeyService))
+    ( __param(6, IHostService)),
+    ( __param(7, IContextKeyService))
 ], WebviewEditor));
 export { CONTEXT_ACTIVE_WEBVIEW_PANEL_ID, WebviewEditor };

package/vscode/src/vs/workbench/contrib/webviewPanel/browser/webviewEditorInput.js

@@ -11,7 +11,7 @@ class WebviewInput extends EditorInput {
         return this.viewType;
     }
     get capabilities() {
-        return 2  | 8  | 128 ;
+        return 2  | 8  | 128  | 1024 ;
     }
     get resource() {
         return ( URI.from({

package/vscode/src/vs/workbench/contrib/webviewPanel/browser/webviewIconManager.js

@@ -1,5 +1,6 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.js';
 let WebviewIconManager = class WebviewIconManager {
@@ -14,12 +15,14 @@ let WebviewIconManager = class WebviewIconManager {
         });
     }
     dispose() {
-        this._styleElement?.remove();
+        this._styleElementDisposable?.dispose();
+        this._styleElementDisposable = undefined;
         this._styleElement = undefined;
     }
     get styleElement() {
         if (!this._styleElement) {
-            this._styleElement = dom.createStyleSheet();
+            this._styleElementDisposable = ( new DisposableStore());
+            this._styleElement = dom.createStyleSheet(undefined, undefined, this._styleElementDisposable);
             this._styleElement.className = 'webview-icons';
         }
         return this._styleElement;

package/vscode/src/vs/workbench/services/activity/browser/activityService.d.ts

@@ -1,20 +1,26 @@
 import { IActivityService, IActivity } from '../common/activity.js';
-import { IDisposable } from '../../../../base/common/lifecycle.js';
-import { IViewDescriptorService } from '../../../common/views.js';
+import { Disposable, IDisposable } from '../../../../base/common/lifecycle.js';
+import { ViewContainer, IViewDescriptorService } from '../../../common/views.js';
+import { Event } from '../../../../base/common/event.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-import { IPaneCompositePartService } from '../../panecomposite/browser/panecomposite.js';
 
-declare class ActivityService implements IActivityService {
-    private readonly paneCompositeService;
+declare class ActivityService extends Disposable implements IActivityService {
     private readonly viewDescriptorService;
     private readonly instantiationService;
     _serviceBrand: undefined;
-    private viewActivities;
-    constructor(paneCompositeService: IPaneCompositePartService, viewDescriptorService: IViewDescriptorService, instantiationService: IInstantiationService);
-    showViewContainerActivity(viewContainerId: string, { badge, clazz, priority }: IActivity): IDisposable;
+    private readonly viewActivities;
+    private readonly _onDidChangeActivity;
+    readonly onDidChangeActivity: Event<string | ViewContainer>;
+    private readonly viewContainerActivities;
+    private readonly globalActivities;
+    constructor(viewDescriptorService: IViewDescriptorService, instantiationService: IInstantiationService);
+    showViewContainerActivity(viewContainerId: string, activity: IActivity): IDisposable;
+    getViewContainerActivities(viewContainerId: string): IActivity[];
     showViewActivity(viewId: string, activity: IActivity): IDisposable;
-    showAccountsActivity({ badge, clazz, priority }: IActivity): IDisposable;
-    showGlobalActivity({ badge, clazz, priority }: IActivity): IDisposable;
+    showAccountsActivity(activity: IActivity): IDisposable;
+    showGlobalActivity(activity: IActivity): IDisposable;
+    getActivity(id: string): IActivity[];
+    private showActivity;
 }
 
 export { ActivityService };

package/vscode/src/vs/workbench/services/activity/common/activity.d.ts

@@ -1,18 +1,27 @@
 import { ServiceIdentifier } from '../../../../platform/instantiation/common/instantiation.js';
 import { IDisposable } from '../../../../base/common/lifecycle.js';
+import { Event } from '../../../../base/common/event.js';
+import { ViewContainer } from '../../../common/views.js';
 
 interface IActivity {
     readonly badge: IBadge;
-    readonly clazz?: string;
     readonly priority?: number;
 }
 declare const IActivityService: ServiceIdentifier<IActivityService>;
 interface IActivityService {
     readonly _serviceBrand: undefined;
+    /**
+     * Emitted when activity changes for a view container or when the activity of the global actions change.
+     */
+    readonly onDidChangeActivity: Event<string | ViewContainer>;
     /**
      * Show activity for the given view container
      */
     showViewContainerActivity(viewContainerId: string, badge: IActivity): IDisposable;
+    /**
+     * Returns the activity for the given view container
+     */
+    getViewContainerActivities(viewContainerId: string): IActivity[];
     /**
      * Show activity for the given view
      */
@@ -25,6 +34,10 @@ interface IActivityService {
      * Show global activity
      */
     showGlobalActivity(activity: IActivity): IDisposable;
+    /**
+     * Return the activity for the given action
+     */
+    getActivity(id: string): IActivity[];
 }
 interface IBadge {
     getDescription(): string;

package/vscode/src/vs/workbench/services/activity/common/activity.js

@@ -19,12 +19,6 @@ class NumberBadge extends BaseBadge {
         return this.descriptorFn(this.number);
     }
 }
-class TextBadge extends BaseBadge {
-    constructor(text, descriptorFn) {
-        super(descriptorFn);
-        this.text = text;
-    }
-}
 class IconBadge extends BaseBadge {
     constructor(icon, descriptorFn) {
         super(descriptorFn);
@@ -33,4 +27,4 @@ class IconBadge extends BaseBadge {
 }
 class ProgressBadge extends BaseBadge {
 }
-export { IActivityService, IconBadge, NumberBadge, ProgressBadge, TextBadge };
+export { IActivityService, IconBadge, NumberBadge, ProgressBadge };

package/vscode/src/vs/workbench/services/authentication/browser/authenticationService.js

@@ -3,7 +3,6 @@ import { flatten } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Disposable, MutableDisposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { isFalsyOrWhitespace } from 'monaco-editor/esm/vs/base/common/strings.js';
-import { isString } from 'monaco-editor/esm/vs/base/common/types.js';
 import * as nls from 'monaco-editor/esm/vs/nls.js';
 import { MenuRegistry, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
@@ -57,24 +56,6 @@ function addAccountUsage(storageService, providerId, accountName, extensionId, e
     }
     storageService.store(accountKey, JSON.stringify(usages), -1 , 1 );
 }
-async function getCurrentAuthenticationSessionInfo(secretStorageService, productService) {
-    const authenticationSessionValue = await secretStorageService.get(`${productService.urlProtocol}.loginAccount`);
-    if (authenticationSessionValue) {
-        try {
-            const authenticationSessionInfo = JSON.parse(authenticationSessionValue);
-            if (authenticationSessionInfo
-                && isString(authenticationSessionInfo.id)
-                && isString(authenticationSessionInfo.accessToken)
-                && isString(authenticationSessionInfo.providerId)) {
-                return authenticationSessionInfo;
-            }
-        }
-        catch (e) {
-            console.error(`Failed parsing current auth session value: ${e}`);
-        }
-    }
-    return undefined;
-}
 function readAllowedExtensions(storageService, providerId, accountName) {
     let trustedExtensions = [];
     try {
@@ -132,7 +113,7 @@ const authenticationExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
         }
     }
 }));
-let placeholderMenuItem = MenuRegistry.appendMenuItem(MenuId.AccountsContext, {
+let placeholderMenuItem = ( MenuRegistry.appendMenuItem(MenuId.AccountsContext, {
     command: {
         id: 'noAuthenticationProviders',
         title: ( nls.localizeWithPath(
@@ -142,7 +123,7 @@ let placeholderMenuItem = MenuRegistry.appendMenuItem(MenuId.AccountsContext, {
         )),
         precondition: ( ContextKeyExpr.false())
     },
-});
+}));
 let AuthenticationService = class AuthenticationService extends Disposable {
     constructor(activityService, extensionService, storageService, dialogService, quickInputService, productService) {
         super();
@@ -237,7 +218,7 @@ let AuthenticationService = class AuthenticationService extends Disposable {
             });
         }
         if (!this._authenticationProviders.size) {
-            placeholderMenuItem = MenuRegistry.appendMenuItem(MenuId.AccountsContext, {
+            placeholderMenuItem = ( MenuRegistry.appendMenuItem(MenuId.AccountsContext, {
                 command: {
                     id: 'noAuthenticationProviders',
                     title: ( nls.localizeWithPath(
@@ -247,7 +228,7 @@ let AuthenticationService = class AuthenticationService extends Disposable {
                     )),
                     precondition: ( ContextKeyExpr.false())
                 },
-            });
+            }));
         }
     }
     async sessionsUpdate(id, event) {
@@ -496,7 +477,7 @@ let AuthenticationService = class AuthenticationService extends Disposable {
         if (hasExistingRequest) {
             return;
         }
-        const menuItem = MenuRegistry.appendMenuItem(MenuId.AccountsContext, {
+        const menuItem = ( MenuRegistry.appendMenuItem(MenuId.AccountsContext, {
             group: '3_accessRequests',
             command: {
                 id: `${providerId}${extensionId}Access`,
@@ -505,7 +486,7 @@ let AuthenticationService = class AuthenticationService extends Disposable {
                     comment: [`The placeholder {0} will be replaced with an authentication provider''s label. {1} will be replaced with an extension name. (1) is to indicate that this menu item contributes to a badge count`]
                 }, "Grant access to {0} for {1}... (1)", this.getLabel(providerId), extensionName))
             }
-        });
+        }));
         const accessCommand = CommandsRegistry.registerCommand({
             id: `${providerId}${extensionId}Access`,
             handler: async (accessor) => {
@@ -542,7 +523,7 @@ let AuthenticationService = class AuthenticationService extends Disposable {
             return;
         }
         const commandId = `${providerId}:${extensionId}:signIn${( Object.keys(providerRequests || [])).length}`;
-        const menuItem = MenuRegistry.appendMenuItem(MenuId.AccountsContext, {
+        const menuItem = ( MenuRegistry.appendMenuItem(MenuId.AccountsContext, {
             group: '2_signInRequests',
             command: {
                 id: commandId,
@@ -551,7 +532,7 @@ let AuthenticationService = class AuthenticationService extends Disposable {
                     comment: [`The placeholder {0} will be replaced with an authentication provider's label. {1} will be replaced with an extension name. (1) is to indicate that this menu item contributes to a badge count.`]
                 }, "Sign in with {0} to use {1} (1)", provider.label, extensionName))
             }
-        });
+        }));
         const signInCommand = CommandsRegistry.registerCommand({
             id: commandId,
             handler: async (accessor) => {
@@ -679,4 +660,4 @@ AuthenticationService = ( __decorate([
     ( __param(4, IQuickInputService)),
     ( __param(5, IProductService))
 ], AuthenticationService));
-export { AuthenticationService, addAccountUsage, getAuthenticationProviderActivationEvent, getCurrentAuthenticationSessionInfo, readAccountUsages, readAllowedExtensions, removeAccountUsage };
+export { AuthenticationService, addAccountUsage, getAuthenticationProviderActivationEvent, readAccountUsages, readAllowedExtensions, removeAccountUsage };