@codingame/monaco-vscode-view-common-service-override 4.5.1 → 5.0.0

package/vscode/src/vs/workbench/services/history/browser/historyService.js

@@ -32,6 +32,7 @@ import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
 
 var HistoryService_1, EditorNavigationStack_1;
+const _moduleId = "vs/workbench/services/history/browser/historyService";
 let HistoryService = class HistoryService extends Disposable {
     static { HistoryService_1 = this; }
     static { this.MOUSE_NAVIGATION_SETTING = 'workbench.editor.mouseBackForwardToNavigate'; }
@@ -49,59 +50,51 @@ let HistoryService = class HistoryService extends Disposable {
         this.layoutService = layoutService;
         this.contextKeyService = contextKeyService;
         this.logService = logService;
-        this.activeEditorListeners = this._register(( new DisposableStore()));
+        this.activeEditorListeners = this._register(( (new DisposableStore())));
         this.lastActiveEditor = undefined;
         this.editorHelper = this.instantiationService.createInstance(EditorHelper);
-        this.canNavigateBackContextKey = (( new RawContextKey('canNavigateBack', false, ( localizeWithPath(
-            'vs/workbench/services/history/browser/historyService',
-            'canNavigateBack',
-            "Whether it is possible to navigate back in editor history"
-        ))))).bindTo(this.contextKeyService);
-        this.canNavigateForwardContextKey = (( new RawContextKey('canNavigateForward', false, ( localizeWithPath(
-            'vs/workbench/services/history/browser/historyService',
-            'canNavigateForward',
+        this.canNavigateBackContextKey = (( (new RawContextKey('canNavigateBack', false, ( localizeWithPath(_moduleId, 0, "Whether it is possible to navigate back in editor history")))))).bindTo(this.contextKeyService);
+        this.canNavigateForwardContextKey = (( (new RawContextKey('canNavigateForward', false, ( localizeWithPath(
+            _moduleId,
+            1,
             "Whether it is possible to navigate forward in editor history"
-        ))))).bindTo(this.contextKeyService);
-        this.canNavigateBackInNavigationsContextKey = (( new RawContextKey('canNavigateBackInNavigationLocations', false, ( localizeWithPath(
-            'vs/workbench/services/history/browser/historyService',
-            'canNavigateBackInNavigationLocations',
+        )))))).bindTo(this.contextKeyService);
+        this.canNavigateBackInNavigationsContextKey = (( (new RawContextKey('canNavigateBackInNavigationLocations', false, ( localizeWithPath(
+            _moduleId,
+            2,
             "Whether it is possible to navigate back in editor navigation locations history"
-        ))))).bindTo(this.contextKeyService);
-        this.canNavigateForwardInNavigationsContextKey = (( new RawContextKey('canNavigateForwardInNavigationLocations', false, ( localizeWithPath(
-            'vs/workbench/services/history/browser/historyService',
-            'canNavigateForwardInNavigationLocations',
+        )))))).bindTo(this.contextKeyService);
+        this.canNavigateForwardInNavigationsContextKey = (( (new RawContextKey('canNavigateForwardInNavigationLocations', false, ( localizeWithPath(
+            _moduleId,
+            3,
             "Whether it is possible to navigate forward in editor navigation locations history"
-        ))))).bindTo(this.contextKeyService);
-        this.canNavigateToLastNavigationLocationContextKey = (( new RawContextKey('canNavigateToLastNavigationLocation', false, ( localizeWithPath(
-            'vs/workbench/services/history/browser/historyService',
-            'canNavigateToLastNavigationLocation',
+        )))))).bindTo(this.contextKeyService);
+        this.canNavigateToLastNavigationLocationContextKey = (( (new RawContextKey('canNavigateToLastNavigationLocation', false, ( localizeWithPath(
+            _moduleId,
+            4,
             "Whether it is possible to navigate to the last editor navigation location"
-        ))))).bindTo(this.contextKeyService);
-        this.canNavigateBackInEditsContextKey = (( new RawContextKey('canNavigateBackInEditLocations', false, ( localizeWithPath(
-            'vs/workbench/services/history/browser/historyService',
-            'canNavigateBackInEditLocations',
+        )))))).bindTo(this.contextKeyService);
+        this.canNavigateBackInEditsContextKey = (( (new RawContextKey('canNavigateBackInEditLocations', false, ( localizeWithPath(
+            _moduleId,
+            5,
             "Whether it is possible to navigate back in editor edit locations history"
-        ))))).bindTo(this.contextKeyService);
-        this.canNavigateForwardInEditsContextKey = (( new RawContextKey('canNavigateForwardInEditLocations', false, ( localizeWithPath(
-            'vs/workbench/services/history/browser/historyService',
-            'canNavigateForwardInEditLocations',
+        )))))).bindTo(this.contextKeyService);
+        this.canNavigateForwardInEditsContextKey = (( (new RawContextKey('canNavigateForwardInEditLocations', false, ( localizeWithPath(
+            _moduleId,
+            6,
             "Whether it is possible to navigate forward in editor edit locations history"
-        ))))).bindTo(this.contextKeyService);
-        this.canNavigateToLastEditLocationContextKey = (( new RawContextKey('canNavigateToLastEditLocation', false, ( localizeWithPath(
-            'vs/workbench/services/history/browser/historyService',
-            'canNavigateToLastEditLocation',
+        )))))).bindTo(this.contextKeyService);
+        this.canNavigateToLastEditLocationContextKey = (( (new RawContextKey('canNavigateToLastEditLocation', false, ( localizeWithPath(
+            _moduleId,
+            7,
             "Whether it is possible to navigate to the last editor edit location"
-        ))))).bindTo(this.contextKeyService);
-        this.canReopenClosedEditorContextKey = (( new RawContextKey('canReopenClosedEditor', false, ( localizeWithPath(
-            'vs/workbench/services/history/browser/historyService',
-            'canReopenClosedEditor',
-            "Whether it is possible to reopen the last closed editor"
-        ))))).bindTo(this.contextKeyService);
-        this._onDidChangeEditorNavigationStack = this._register(( new Emitter()));
+        )))))).bindTo(this.contextKeyService);
+        this.canReopenClosedEditorContextKey = (( (new RawContextKey('canReopenClosedEditor', false, ( localizeWithPath(_moduleId, 8, "Whether it is possible to reopen the last closed editor")))))).bindTo(this.contextKeyService);
+        this._onDidChangeEditorNavigationStack = this._register(( (new Emitter())));
         this.onDidChangeEditorNavigationStack = this._onDidChangeEditorNavigationStack.event;
         this.defaultScopedEditorNavigationStack = undefined;
-        this.editorGroupScopedNavigationStacks = ( new Map());
-        this.editorScopedNavigationStacks = ( new Map());
+        this.editorGroupScopedNavigationStacks = ( (new Map()));
+        this.editorScopedNavigationStacks = ( (new Map()));
         this.editorNavigationScope = 0 ;
         this.recentlyUsedEditorsStack = undefined;
         this.recentlyUsedEditorsStackIndex = 0;
@@ -112,12 +105,12 @@ let HistoryService = class HistoryService extends Disposable {
         this.recentlyClosedEditors = [];
         this.ignoreEditorCloseEvent = false;
         this.history = undefined;
-        this.editorHistoryListeners = ( new Map());
-        this.resourceExcludeMatcher = this._register(( new WindowIdleValue(mainWindow, () => {
+        this.editorHistoryListeners = ( (new Map()));
+        this.resourceExcludeMatcher = this._register(( (new WindowIdleValue(mainWindow, () => {
             const matcher = this._register(this.instantiationService.createInstance(ResourceGlobMatcher, root => getExcludes(root ? this.configurationService.getValue({ resource: root }) : this.configurationService.getValue()) || Object.create(null), event => event.affectsConfiguration(FILES_EXCLUDE_CONFIG) || event.affectsConfiguration(SEARCH_EXCLUDE_CONFIG)));
             this._register(matcher.onExpressionChange(() => this.removeExcludedFromHistory()));
             return matcher;
-        })));
+        }))));
         this.registerListeners();
         if (this.editorService.activeEditorPane) {
             this.onDidActiveEditorChange();
@@ -142,12 +135,12 @@ let HistoryService = class HistoryService extends Disposable {
         this.handleEditorCloseEventInReopen(e);
     }
     registerMouseNavigationListener() {
-        const mouseBackForwardSupportListener = this._register(( new DisposableStore()));
+        const mouseBackForwardSupportListener = this._register(( (new DisposableStore())));
         const handleMouseBackForwardSupport = () => {
             mouseBackForwardSupportListener.clear();
             if (this.configurationService.getValue(HistoryService_1.MOUSE_NAVIGATION_SETTING)) {
                 this._register(Event.runAndSubscribe(this.layoutService.onDidAddContainer, ({ container, disposables }) => {
-                    const eventDisposables = disposables.add(( new DisposableStore()));
+                    const eventDisposables = disposables.add(( (new DisposableStore())));
                     eventDisposables.add(addDisposableListener(container, EventType.MOUSE_DOWN, e => this.onMouseDownOrUp(e, true)));
                     eventDisposables.add(addDisposableListener(container, EventType.MOUSE_UP, e => this.onMouseDownOrUp(e, false)));
                     mouseBackForwardSupportListener.add(eventDisposables);
@@ -296,16 +289,18 @@ let HistoryService = class HistoryService extends Disposable {
         switch (this.editorNavigationScope) {
             case 2 : {
                 if (!editor) {
-                    return ( new NoOpEditorNavigationStacks());
+                    return (
+                         (new NoOpEditorNavigationStacks())
+                    );
                 }
                 let stacksForGroup = this.editorScopedNavigationStacks.get(group.id);
                 if (!stacksForGroup) {
-                    stacksForGroup = ( new Map());
+                    stacksForGroup = ( (new Map()));
                     this.editorScopedNavigationStacks.set(group.id, stacksForGroup);
                 }
                 let stack = stacksForGroup.get(editor)?.stack;
                 if (!stack) {
-                    const disposable = ( new DisposableStore());
+                    const disposable = ( (new DisposableStore()));
                     stack = disposable.add(this.instantiationService.createInstance(EditorNavigationStacks, 2 ));
                     disposable.add(stack.onDidChange(() => this._onDidChangeEditorNavigationStack.fire()));
                     stacksForGroup.set(editor, { stack, disposable });
@@ -315,7 +310,7 @@ let HistoryService = class HistoryService extends Disposable {
             case 1 : {
                 let stack = this.editorGroupScopedNavigationStacks.get(group.id)?.stack;
                 if (!stack) {
-                    const disposable = ( new DisposableStore());
+                    const disposable = ( (new DisposableStore()));
                     stack = disposable.add(this.instantiationService.createInstance(EditorNavigationStacks, 1 ));
                     disposable.add(stack.onDidChange(() => this._onDidChangeEditorNavigationStack.fire()));
                     this.editorGroupScopedNavigationStacks.set(group.id, { stack, disposable });
@@ -446,7 +441,7 @@ let HistoryService = class HistoryService extends Disposable {
             index = this.recentlyUsedEditorsStackIndex;
         }
         else {
-            editors = this.recentlyUsedEditorsInGroupStack || ( group.getEditors(0 ).map(editor => ({ groupId: group.id, editor })));
+            editors = this.recentlyUsedEditorsInGroupStack || ( (group.getEditors(0 ).map(editor => ({ groupId: group.id, editor }))));
             index = this.recentlyUsedEditorsInGroupStackIndex;
         }
         let newIndex = indexModifier(index);
@@ -555,9 +550,9 @@ let HistoryService = class HistoryService extends Disposable {
             if (recentlyClosedEditor.resource && this.editorHelper.matchesFile(recentlyClosedEditor.resource, arg1)) {
                 return false;
             }
-            if (( recentlyClosedEditor.associatedResources.some(
+            if (( (recentlyClosedEditor.associatedResources.some(
                 associatedResource => this.editorHelper.matchesFile(associatedResource, arg1)
-            ))) {
+            )))) {
                 return false;
             }
             return true;
@@ -665,7 +660,7 @@ let HistoryService = class HistoryService extends Disposable {
                     replaced = true;
                 }
             }
-            else if (!( replacements.some(replacement => this.editorHelper.matchesEditor(replacement, entry)))) {
+            else if (!( (replacements.some(replacement => this.editorHelper.matchesEditor(replacement, entry))))) {
                 newHistory.push(entry);
             }
         }
@@ -703,18 +698,20 @@ let HistoryService = class HistoryService extends Disposable {
         this.history = [];
         const storedEditorHistory = this.loadHistoryFromStorage();
         const openedEditorsLru = [...this.editorService.getEditors(0 )].reverse();
-        const handledEditors = ( new Set());
+        const handledEditors = ( (new Set()));
         for (const { editor } of openedEditorsLru) {
             if (!this.includeInHistory(editor)) {
                 continue;
             }
             this.addToHistory(editor);
             if (editor.resource) {
-                handledEditors.add(`${( editor.resource.toString())}/${editor.editorId}`);
+                handledEditors.add(`${( (editor.resource.toString()))}/${editor.editorId}`);
             }
         }
         for (const editor of storedEditorHistory) {
-            if (!( handledEditors.has(`${( editor.resource.toString())}/${editor.options?.override}`)) &&
+            if (!( (handledEditors.has(
+                `${( (editor.resource.toString()))}/${editor.options?.override}`
+            ))) &&
                 this.includeInHistory(editor)) {
                 this.addToHistory(editor, false );
             }
@@ -735,8 +732,8 @@ let HistoryService = class HistoryService extends Disposable {
                             ...entryParsed.editor,
                             resource: typeof entryParsed.editor.resource === 'string' ?
                                 (
-                                URI.parse(entryParsed.editor.resource)) :
-                                ( URI.from(entryParsed.editor.resource))
+                                (URI.parse(entryParsed.editor.resource))) :
+                                ( (URI.from(entryParsed.editor.resource)))
                         });
                     }
                     catch (error) {
@@ -762,7 +759,7 @@ let HistoryService = class HistoryService extends Disposable {
             entries.push({
                 editor: {
                     ...editor,
-                    resource: ( editor.resource.toString())
+                    resource: ( (editor.resource.toString()))
                 }
             });
         }
@@ -833,20 +830,20 @@ let HistoryService = class HistoryService extends Disposable {
         }
     }
 };
-HistoryService = HistoryService_1 = ( __decorate([
-    ( __param(0, IEditorService)),
-    ( __param(1, IEditorGroupsService)),
-    ( __param(2, IWorkspaceContextService)),
-    ( __param(3, IStorageService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IFileService)),
-    ( __param(6, IWorkspacesService)),
-    ( __param(7, IInstantiationService)),
-    ( __param(8, IWorkbenchLayoutService)),
-    ( __param(9, IContextKeyService)),
-    ( __param(10, ILogService))
-], HistoryService));
-( registerSingleton(IHistoryService, HistoryService, 0 ));
+HistoryService = HistoryService_1 = ( (__decorate([
+    ( (__param(0, IEditorService))),
+    ( (__param(1, IEditorGroupsService))),
+    ( (__param(2, IWorkspaceContextService))),
+    ( (__param(3, IStorageService))),
+    ( (__param(4, IConfigurationService))),
+    ( (__param(5, IFileService))),
+    ( (__param(6, IWorkspacesService))),
+    ( (__param(7, IInstantiationService))),
+    ( (__param(8, IWorkbenchLayoutService))),
+    ( (__param(9, IContextKeyService))),
+    ( (__param(10, ILogService)))
+], HistoryService)));
+( (registerSingleton(IHistoryService, HistoryService, 0 )));
 class EditorSelectionState {
     constructor(editorIdentifier, selection, reason) {
         this.editorIdentifier = editorIdentifier;
@@ -948,9 +945,9 @@ let EditorNavigationStacks = class EditorNavigationStacks extends Disposable {
         }
     }
 };
-EditorNavigationStacks = ( __decorate([
-    ( __param(1, IInstantiationService))
-], EditorNavigationStacks));
+EditorNavigationStacks = ( (__decorate([
+    ( (__param(1, IInstantiationService)))
+], EditorNavigationStacks)));
 class NoOpEditorNavigationStacks {
     constructor() {
         this.onDidChange = Event.None;
@@ -988,10 +985,10 @@ let EditorNavigationStack = class EditorNavigationStack extends Disposable {
         this.editorService = editorService;
         this.editorGroupService = editorGroupService;
         this.logService = logService;
-        this._onDidChange = this._register(( new Emitter()));
+        this._onDidChange = this._register(( (new Emitter())));
         this.onDidChange = this._onDidChange.event;
-        this.mapEditorToDisposable = ( new Map());
-        this.mapGroupToDisposable = ( new Map());
+        this.mapEditorToDisposable = ( (new Map()));
+        this.mapGroupToDisposable = ( (new Map()));
         this.editorHelper = this.instantiationService.createInstance(EditorHelper);
         this.stack = [];
         this.index = -1;
@@ -1074,7 +1071,7 @@ ${entryLabels.join('\n')}
         }
     }
     registerGroupListeners(groupId) {
-        if (!( this.mapGroupToDisposable.has(groupId))) {
+        if (!( (this.mapGroupToDisposable.has(groupId)))) {
             const group = this.editorGroupService.getGroup(groupId);
             if (group) {
                 this.mapGroupToDisposable.set(groupId, group.onWillMoveEditor(e => this.onWillMoveEditor(e)));
@@ -1104,11 +1101,11 @@ ${entryLabels.join('\n')}
             this.trace(`notifyNavigation() ignoring (navigating)`, editorPane?.input, event);
             if (isSelectionAwareEditorPane && hasValidEditor) {
                 this.trace('notifyNavigation() updating current selection state', editorPane?.input, event);
-                this.currentSelectionState = ( new EditorSelectionState(
+                this.currentSelectionState = ( (new EditorSelectionState(
                     { groupId: editorPane.group.id, editor: editorPane.input },
                     editorPane.getSelection(),
                     event?.reason
-                ));
+                )));
             }
             else {
                 this.trace('notifyNavigation() dropping current selection state', editorPane?.input, event);
@@ -1133,7 +1130,7 @@ ${entryLabels.join('\n')}
             return;
         }
         this.trace('onSelectionAwareEditorNavigation()', editor, event);
-        const stateCandidate = ( new EditorSelectionState({ groupId, editor }, selection, event?.reason));
+        const stateCandidate = ( (new EditorSelectionState({ groupId, editor }, selection, event?.reason)));
         if (!this.currentSelectionState || this.currentSelectionState.justifiesNewNavigationEntry(stateCandidate)) {
             this.doAdd(groupId, editor, stateCandidate.selection);
         }
@@ -1405,12 +1402,12 @@ ${entryLabels.join('\n')}
         return this.navigating;
     }
 };
-EditorNavigationStack = EditorNavigationStack_1 = ( __decorate([
-    ( __param(2, IInstantiationService)),
-    ( __param(3, IEditorService)),
-    ( __param(4, IEditorGroupsService)),
-    ( __param(5, ILogService))
-], EditorNavigationStack));
+EditorNavigationStack = EditorNavigationStack_1 = ( (__decorate([
+    ( (__param(2, IInstantiationService))),
+    ( (__param(3, IEditorService))),
+    ( (__param(4, IEditorGroupsService))),
+    ( (__param(5, ILogService)))
+], EditorNavigationStack)));
 let EditorHelper = class EditorHelper {
     constructor(uriIdentityService, lifecycleService, fileService, pathService) {
         this.uriIdentityService = uriIdentityService;
@@ -1490,7 +1487,7 @@ let EditorHelper = class EditorHelper {
         const toDispose = Event.once(editor.onWillDispose)(() => listener());
         let disposables = mapEditorToDispose.get(editor);
         if (!disposables) {
-            disposables = ( new DisposableStore());
+            disposables = ( (new DisposableStore()));
             mapEditorToDispose.set(editor, disposables);
         }
         disposables.add(toDispose);
@@ -1506,11 +1503,11 @@ let EditorHelper = class EditorHelper {
         }
     }
 };
-EditorHelper = ( __decorate([
-    ( __param(0, IUriIdentityService)),
-    ( __param(1, ILifecycleService)),
-    ( __param(2, IFileService)),
-    ( __param(3, IPathService))
-], EditorHelper));
+EditorHelper = ( (__decorate([
+    ( (__param(0, IUriIdentityService))),
+    ( (__param(1, ILifecycleService))),
+    ( (__param(2, IFileService))),
+    ( (__param(3, IPathService)))
+], EditorHelper)));
 
 export { EditorNavigationStack, HistoryService };

package/vscode/src/vs/workbench/services/progress/browser/progressService.js

@@ -24,6 +24,7 @@ import { stripIcons } from 'vscode/vscode/vs/base/common/iconLabels';
 import { defaultButtonStyles, defaultCheckboxStyles, defaultInputBoxStyles, defaultDialogStyles } from 'vscode/vscode/vs/platform/theme/browser/defaultStyles';
 import Severity$1 from 'vscode/vscode/vs/base/common/severity';
 
+const _moduleId = "vs/workbench/services/progress/browser/progressService";
 let ProgressService = class ProgressService extends Disposable {
     constructor(activityService, paneCompositeService, viewDescriptorService, viewsService, notificationService, statusbarService, layoutService, keybindingService) {
         super();
@@ -51,7 +52,7 @@ let ProgressService = class ProgressService extends Disposable {
             if (this.viewDescriptorService.getViewDescriptorById(location) !== null) {
                 return this.withViewProgress(location, task, { ...options, location });
             }
-            throw new Error(`Bad progress location: ${location}`);
+            throw ( (new Error(`Bad progress location: ${location}`)));
         };
         if (typeof location === 'string') {
             return handleStringLocation(location);
@@ -85,11 +86,11 @@ let ProgressService = class ProgressService extends Disposable {
             case 20 :
                 return this.withDialogProgress(options, task, onDidCancel);
             default:
-                throw new Error(`Bad progress location: ${location}`);
+                throw ( (new Error(`Bad progress location: ${location}`)));
         }
     }
     withWindowProgress(options, callback) {
-        const task = [options, ( new Progress(() => this.updateWindowProgress()))];
+        const task = [options, ( (new Progress(() => this.updateWindowProgress())))];
         const promise = callback(task[1]);
         let delayHandle = setTimeout(() => {
             delayHandle = undefined;
@@ -116,52 +117,23 @@ let ProgressService = class ProgressService extends Disposable {
             let title;
             const source = options.source && typeof options.source !== 'string' ? options.source.label : options.source;
             if (progressTitle && progressMessage) {
-                text = ( localizeWithPath(
-                    'vs/workbench/services/progress/browser/progressService',
-                    'progress.text2',
-                    "{0}: {1}",
-                    progressTitle,
-                    progressMessage
-                ));
-                title = source ? ( localizeWithPath(
-                    'vs/workbench/services/progress/browser/progressService',
-                    'progress.title3',
-                    "[{0}] {1}: {2}",
-                    source,
-                    progressTitle,
-                    progressMessage
-                )) : text;
+                text = ( localizeWithPath(_moduleId, 0, "{0}: {1}", progressTitle, progressMessage));
+                title = source ? ( localizeWithPath(_moduleId, 1, "[{0}] {1}: {2}", source, progressTitle, progressMessage)) : text;
             }
             else if (progressTitle) {
                 text = progressTitle;
-                title = source ? ( localizeWithPath(
-                    'vs/workbench/services/progress/browser/progressService',
-                    'progress.title2',
-                    "[{0}]: {1}",
-                    source,
-                    progressTitle
-                )) : text;
+                title = source ? ( localizeWithPath(_moduleId, 2, "[{0}]: {1}", source, progressTitle)) : text;
             }
             else if (progressMessage) {
                 text = progressMessage;
-                title = source ? ( localizeWithPath(
-                    'vs/workbench/services/progress/browser/progressService',
-                    'progress.title2',
-                    "[{0}]: {1}",
-                    source,
-                    progressMessage
-                )) : text;
+                title = source ? ( localizeWithPath(_moduleId, 2, "[{0}]: {1}", source, progressMessage)) : text;
             }
             else {
                 this.updateWindowProgress(idx + 1);
                 return;
             }
             const statusEntryProperties = {
-                name: ( localizeWithPath(
-                    'vs/workbench/services/progress/browser/progressService',
-                    'status.progress',
-                    "Progress Message"
-                )),
+                name: ( localizeWithPath(_moduleId, 3, "Progress Message")),
                 text,
                 showProgress: options.type || true,
                 ariaLabel: text,
@@ -186,9 +158,9 @@ let ProgressService = class ProgressService extends Disposable {
             get done() { return this._done; }
             constructor() {
                 super();
-                this._onDidReport = this._register(( new Emitter()));
+                this._onDidReport = this._register(( (new Emitter())));
                 this.onDidReport = this._onDidReport.event;
-                this._onWillDispose = this._register(( new Emitter()));
+                this._onWillDispose = this._register(( (new Emitter())));
                 this.onWillDispose = this._onWillDispose.event;
                 this._step = undefined;
                 this._done = false;
@@ -212,17 +184,17 @@ let ProgressService = class ProgressService extends Disposable {
             }
         });
         const createWindowProgress = () => {
-            const promise = ( new DeferredPromise());
+            const promise = ( (new DeferredPromise()));
             this.withWindowProgress({
                 location: 10 ,
-                title: options.title ? ( parseLinkedText(options.title).toString()) : undefined,
+                title: options.title ? ( (parseLinkedText(options.title).toString())) : undefined,
                 command: 'notifications.showList',
                 type: options.type
             }, progress => {
                 function reportProgress(step) {
                     if (step.message) {
                         progress.report({
-                            message: ( parseLinkedText(step.message).toString())
+                            message: ( (parseLinkedText(step.message).toString()))
                         });
                     }
                 }
@@ -237,7 +209,7 @@ let ProgressService = class ProgressService extends Disposable {
             return toDisposable(() => promise.complete());
         };
         const createNotification = (message, priority, increment) => {
-            const notificationDisposables = ( new DisposableStore());
+            const notificationDisposables = ( (new DisposableStore()));
             const primaryActions = options.primaryActions ? Array.from(options.primaryActions) : [];
             const secondaryActions = options.secondaryActions ? Array.from(options.secondaryActions) : [];
             if (options.buttons) {
@@ -257,11 +229,7 @@ let ProgressService = class ProgressService extends Disposable {
             if (options.cancellable) {
                 const cancelAction = new (class extends Action {
                     constructor() {
-                        super('progress.cancel', ( localizeWithPath(
-                            'vs/workbench/services/progress/browser/progressService',
-                            'cancel',
-                            "Cancel"
-                        )), undefined, true);
+                        super('progress.cancel', ( localizeWithPath(_moduleId, 4, "Cancel")), undefined, true);
                     }
                     async run() {
                         progressStateModel.cancel();
@@ -375,7 +343,7 @@ let ProgressService = class ProgressService extends Disposable {
         let activityProgress;
         let delayHandle = setTimeout(() => {
             delayHandle = undefined;
-            const handle = this.activityService.showViewContainerActivity(viewletId, { badge: ( new ProgressBadge(() => '')), priority: 100 });
+            const handle = this.activityService.showViewContainerActivity(viewletId, { badge: ( (new ProgressBadge(() => ''))), priority: 100 });
             const startTimeVisible = Date.now();
             const minTimeVisible = 300;
             activityProgress = {
@@ -433,7 +401,7 @@ let ProgressService = class ProgressService extends Disposable {
         return promise;
     }
     withDialogProgress(options, task, onDidCancel) {
-        const disposables = ( new DisposableStore());
+        const disposables = ( (new DisposableStore()));
         const allowableCommands = [
             'workbench.action.quit',
             'workbench.action.reloadWindow',
@@ -446,17 +414,9 @@ let ProgressService = class ProgressService extends Disposable {
         const createDialog = (message) => {
             const buttons = options.buttons || [];
             if (!options.sticky) {
-                buttons.push(options.cancellable ? ( localizeWithPath(
-                    'vs/workbench/services/progress/browser/progressService',
-                    'cancel',
-                    "Cancel"
-                )) : ( localizeWithPath(
-                    'vs/workbench/services/progress/browser/progressService',
-                    'dismiss',
-                    "Dismiss"
-                )));
-            }
-            dialog = ( new Dialog(this.layoutService.activeContainer, message, buttons, {
+                buttons.push(options.cancellable ? ( localizeWithPath(_moduleId, 4, "Cancel")) : ( localizeWithPath(_moduleId, 5, "Dismiss")));
+            }
+            dialog = ( (new Dialog(this.layoutService.activeContainer, message, buttons, {
                 type: 'pending',
                 detail: options.detail,
                 cancelId: buttons.length - 1,
@@ -474,7 +434,7 @@ let ProgressService = class ProgressService extends Disposable {
                 checkboxStyles: defaultCheckboxStyles,
                 inputBoxStyles: defaultInputBoxStyles,
                 dialogStyles: defaultDialogStyles
-            }));
+            })));
             disposables.add(dialog);
             dialog.show().then(dialogResult => {
                 onDidCancel?.(dialogResult.button);
@@ -484,7 +444,7 @@ let ProgressService = class ProgressService extends Disposable {
         };
         let delay = options.delay ?? 0;
         let latestMessage = undefined;
-        const scheduler = disposables.add(( new RunOnceScheduler(() => {
+        const scheduler = disposables.add(( (new RunOnceScheduler(() => {
             delay = 0;
             if (latestMessage && !dialog) {
                 dialog = createDialog(latestMessage);
@@ -492,7 +452,7 @@ let ProgressService = class ProgressService extends Disposable {
             else if (latestMessage) {
                 dialog.updateMessage(latestMessage);
             }
-        }, 0)));
+        }, 0))));
         const updateDialog = function (message) {
             latestMessage = message;
             if (!scheduler.isScheduled()) {
@@ -513,15 +473,15 @@ let ProgressService = class ProgressService extends Disposable {
         return promise;
     }
 };
-ProgressService = ( __decorate([
-    ( __param(0, IActivityService)),
-    ( __param(1, IPaneCompositePartService)),
-    ( __param(2, IViewDescriptorService)),
-    ( __param(3, IViewsService)),
-    ( __param(4, INotificationService)),
-    ( __param(5, IStatusbarService)),
-    ( __param(6, ILayoutService)),
-    ( __param(7, IKeybindingService))
-], ProgressService));
+ProgressService = ( (__decorate([
+    ( (__param(0, IActivityService))),
+    ( (__param(1, IPaneCompositePartService))),
+    ( (__param(2, IViewDescriptorService))),
+    ( (__param(3, IViewsService))),
+    ( (__param(4, INotificationService))),
+    ( (__param(5, IStatusbarService))),
+    ( (__param(6, ILayoutService))),
+    ( (__param(7, IKeybindingService)))
+], ProgressService)));
 
 export { ProgressService };