@codingame/monaco-vscode-debug-service-override 7.1.0 → 8.0.0

package/vscode/src/vs/workbench/contrib/debug/browser/debugSession.js

@@ -13,7 +13,7 @@ import { basenameOrAuthority } from 'vscode/vscode/vs/base/common/resources';
 import Severity$1 from 'vscode/vscode/vs/base/common/severity';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { localize } from 'vscode/vscode/vs/nls';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
@@ -40,11 +40,11 @@ import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
 import { isDefined } from 'vscode/vscode/vs/base/common/types';
 import { ITestService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testService.service';
 import { ITestResultService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testResultService.service';
+import { IAccessibilityService } from 'vscode/vscode/vs/platform/accessibility/common/accessibility.service';
 
-const _moduleId = "vs/workbench/contrib/debug/browser/debugSession";
 const TRIGGERED_BREAKPOINT_MAX_DELAY = 1500;
 let DebugSession = class DebugSession {
-    constructor(id, _configuration, root, model, options, debugService, telemetryService, hostService, configurationService, paneCompositeService, workspaceContextService, productService, notificationService, lifecycleService, uriIdentityService, instantiationService, customEndpointTelemetryService, workbenchEnvironmentService, logService, testService, testResultService) {
+    constructor(id, _configuration, root, model, options, debugService, telemetryService, hostService, configurationService, paneCompositeService, workspaceContextService, productService, notificationService, lifecycleService, uriIdentityService, instantiationService, customEndpointTelemetryService, workbenchEnvironmentService, logService, testService, testResultService, accessibilityService) {
         this.id = id;
         this._configuration = _configuration;
         this.root = root;
@@ -63,6 +63,7 @@ let DebugSession = class DebugSession {
         this.workbenchEnvironmentService = workbenchEnvironmentService;
         this.logService = logService;
         this.testService = testService;
+        this.accessibilityService = accessibilityService;
         this.initialized = false;
         this.sources = ( (new Map()));
         this.threads = ( (new Map()));
@@ -92,7 +93,7 @@ let DebugSession = class DebugSession {
         }
         const toDispose = this.globalDisposables;
         const replListener = toDispose.add(( (new MutableDisposable())));
-        replListener.value = this.repl.onDidChangeElements(() => this._onDidChangeREPLElements.fire());
+        replListener.value = this.repl.onDidChangeElements((e) => this._onDidChangeREPLElements.fire(e));
         if (lifecycleService) {
             toDispose.add(lifecycleService.onWillShutdown(() => {
                 this.shutdown();
@@ -132,7 +133,7 @@ let DebugSession = class DebugSession {
             toDispose.add(parent.onDidEndAdapter(() => {
                 if (!this.hasSeparateRepl() && this.raw?.isInShutdown === false) {
                     this.repl = this.repl.clone();
-                    replListener.value = this.repl.onDidChangeElements(() => this._onDidChangeREPLElements.fire());
+                    replListener.value = this.repl.onDidChangeElements((e) => this._onDidChangeREPLElements.fire(e));
                     this.parentSession = undefined;
                 }
             }));
@@ -180,7 +181,9 @@ let DebugSession = class DebugSession {
         return this._options.suppressDebugView ?? false;
     }
     get autoExpandLazyVariables() {
-        return this.configurationService.getValue('debug').autoExpandLazyVariables;
+        const screenReaderOptimized = this.accessibilityService.isScreenReaderOptimized();
+        const value = this.configurationService.getValue('debug').autoExpandLazyVariables;
+        return value === 'auto' && screenReaderOptimized || value === 'on';
     }
     setConfiguration(configuration) {
         this._configuration = configuration;
@@ -286,12 +289,9 @@ let DebugSession = class DebugSession {
     }
     async launchOrAttach(config) {
         if (!this.raw) {
-            throw ( (new Error(localizeWithPath(
-                _moduleId,
-                0,
-                "No debugger available, can not send '{0}'",
-                'launch or attach'
-            ))));
+            throw ( (new Error(
+                localize(5753, "No debugger available, can not send '{0}'", 'launch or attach')
+            )));
         }
         if (this.parentSession && this.parentSession.state === State.Inactive) {
             throw canceled();
@@ -346,9 +346,7 @@ let DebugSession = class DebugSession {
     }
     async restart() {
         if (!this.raw) {
-            throw ( (new Error(
-                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'restart')
-            )));
+            throw ( (new Error(localize(5753, "No debugger available, can not send '{0}'", 'restart'))));
         }
         this.cancelAllRequests();
         if (this._options.lifecycleManagedByParent && this.parentSession) {
@@ -360,9 +358,7 @@ let DebugSession = class DebugSession {
     }
     async sendBreakpoints(modelUri, breakpointsToSend, sourceModified) {
         if (!this.raw) {
-            throw ( (new Error(
-                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'breakpoints')
-            )));
+            throw ( (new Error(localize(5753, "No debugger available, can not send '{0}'", 'breakpoints'))));
         }
         if (!this.raw.readyForBreakpoints) {
             return Promise.resolve(undefined);
@@ -390,12 +386,9 @@ let DebugSession = class DebugSession {
     }
     async sendFunctionBreakpoints(fbpts) {
         if (!this.raw) {
-            throw ( (new Error(localizeWithPath(
-                _moduleId,
-                0,
-                "No debugger available, can not send '{0}'",
-                'function breakpoints'
-            ))));
+            throw ( (new Error(
+                localize(5753, "No debugger available, can not send '{0}'", 'function breakpoints')
+            )));
         }
         if (this.raw.readyForBreakpoints) {
             const response = await this.raw.setFunctionBreakpoints({ breakpoints: ( (fbpts.map(bp => bp.toDAP()))) });
@@ -410,12 +403,9 @@ let DebugSession = class DebugSession {
     }
     async sendExceptionBreakpoints(exbpts) {
         if (!this.raw) {
-            throw ( (new Error(localizeWithPath(
-                _moduleId,
-                0,
-                "No debugger available, can not send '{0}'",
-                'exception breakpoints'
-            ))));
+            throw ( (new Error(
+                localize(5753, "No debugger available, can not send '{0}'", 'exception breakpoints')
+            )));
         }
         if (this.raw.readyForBreakpoints) {
             const args = this.capabilities.supportsExceptionFilterOptions ? {
@@ -439,9 +429,7 @@ let DebugSession = class DebugSession {
     }
     dataBytesBreakpointInfo(address, bytes) {
         if (this.raw?.capabilities.supportsDataBreakpointBytes === false) {
-            throw ( (new Error(
-                localizeWithPath(_moduleId, 1, "Session does not support breakpoints with bytes")
-            )));
+            throw ( (new Error(localize(5754, "Session does not support breakpoints with bytes"))));
         }
         return this._dataBreakpointInfo({ name: address, bytes, asAddress: true });
     }
@@ -450,27 +438,21 @@ let DebugSession = class DebugSession {
     }
     async _dataBreakpointInfo(args) {
         if (!this.raw) {
-            throw ( (new Error(localizeWithPath(
-                _moduleId,
-                0,
-                "No debugger available, can not send '{0}'",
-                'data breakpoints info'
-            ))));
+            throw ( (new Error(
+                localize(5754, "No debugger available, can not send '{0}'", 'data breakpoints info')
+            )));
         }
         if (!this.raw.readyForBreakpoints) {
-            throw ( (new Error(localizeWithPath(_moduleId, 2, "Session is not ready for breakpoints"))));
+            throw ( (new Error(localize(5755, "Session is not ready for breakpoints"))));
         }
         const response = await this.raw.dataBreakpointInfo(args);
         return response?.body;
     }
     async sendDataBreakpoints(dataBreakpoints) {
         if (!this.raw) {
-            throw ( (new Error(localizeWithPath(
-                _moduleId,
-                0,
-                "No debugger available, can not send '{0}'",
-                'data breakpoints'
-            ))));
+            throw ( (new Error(
+                localize(5755, "No debugger available, can not send '{0}'", 'data breakpoints')
+            )));
         }
         if (this.raw.readyForBreakpoints) {
             const converted = await Promise.all(( (dataBreakpoints.map(async (bp) => {
@@ -500,9 +482,8 @@ let DebugSession = class DebugSession {
     }
     async sendInstructionBreakpoints(instructionBreakpoints) {
         if (!this.raw) {
-            throw ( (new Error(localizeWithPath(
-                _moduleId,
-                0,
+            throw ( (new Error(localize(
+                5755,
                 "No debugger available, can not send '{0}'",
                 'instruction breakpoints'
             ))));
@@ -520,12 +501,9 @@ let DebugSession = class DebugSession {
     }
     async breakpointsLocations(uri, lineNumber) {
         if (!this.raw) {
-            throw ( (new Error(localizeWithPath(
-                _moduleId,
-                0,
-                "No debugger available, can not send '{0}'",
-                'breakpoints locations'
-            ))));
+            throw ( (new Error(
+                localize(5755, "No debugger available, can not send '{0}'", 'breakpoints locations')
+            )));
         }
         const source = this.getRawSource(uri);
         const response = await this.raw.breakpointLocations({ source, line: lineNumber });
@@ -540,17 +518,13 @@ let DebugSession = class DebugSession {
     }
     customRequest(request, args) {
         if (!this.raw) {
-            throw ( (new Error(
-                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", request)
-            )));
+            throw ( (new Error(localize(5755, "No debugger available, can not send '{0}'", request))));
         }
         return this.raw.custom(request, args);
     }
     stackTrace(threadId, startFrame, levels, token) {
         if (!this.raw) {
-            throw ( (new Error(
-                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'stackTrace')
-            )));
+            throw ( (new Error(localize(5755, "No debugger available, can not send '{0}'", 'stackTrace'))));
         }
         const sessionToken = this.getNewCancellationToken(threadId, token);
         return this.raw.stackTrace({ threadId, startFrame, levels }, sessionToken);
@@ -558,7 +532,7 @@ let DebugSession = class DebugSession {
     async exceptionInfo(threadId) {
         if (!this.raw) {
             throw ( (new Error(
-                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'exceptionInfo')
+                localize(5755, "No debugger available, can not send '{0}'", 'exceptionInfo')
             )));
         }
         const response = await this.raw.exceptionInfo({ threadId });
@@ -574,27 +548,21 @@ let DebugSession = class DebugSession {
     }
     scopes(frameId, threadId) {
         if (!this.raw) {
-            throw ( (new Error(
-                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'scopes')
-            )));
+            throw ( (new Error(localize(5755, "No debugger available, can not send '{0}'", 'scopes'))));
         }
         const token = this.getNewCancellationToken(threadId);
         return this.raw.scopes({ frameId }, token);
     }
     variables(variablesReference, threadId, filter, start, count) {
         if (!this.raw) {
-            throw ( (new Error(
-                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'variables')
-            )));
+            throw ( (new Error(localize(5755, "No debugger available, can not send '{0}'", 'variables'))));
         }
         const token = threadId ? this.getNewCancellationToken(threadId) : undefined;
         return this.raw.variables({ variablesReference, filter, start, count }, token);
     }
     evaluate(expression, frameId, context, location) {
         if (!this.raw) {
-            throw ( (new Error(
-                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'evaluate')
-            )));
+            throw ( (new Error(localize(5755, "No debugger available, can not send '{0}'", 'evaluate'))));
         }
         return this.raw.evaluate({ expression, frameId, context, line: location?.line, column: location?.column, source: location?.source });
     }
@@ -602,7 +570,7 @@ let DebugSession = class DebugSession {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
             throw ( (new Error(
-                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'restartFrame')
+                localize(5755, "No debugger available, can not send '{0}'", 'restartFrame')
             )));
         }
         await this.raw.restartFrame({ frameId }, threadId);
@@ -616,9 +584,7 @@ let DebugSession = class DebugSession {
     async next(threadId, granularity) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( (new Error(
-                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'next')
-            )));
+            throw ( (new Error(localize(5755, "No debugger available, can not send '{0}'", 'next'))));
         }
         this.setLastSteppingGranularity(threadId, granularity);
         await this.raw.next({ threadId, granularity });
@@ -626,9 +592,7 @@ let DebugSession = class DebugSession {
     async stepIn(threadId, targetId, granularity) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( (new Error(
-                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'stepIn')
-            )));
+            throw ( (new Error(localize(5755, "No debugger available, can not send '{0}'", 'stepIn'))));
         }
         this.setLastSteppingGranularity(threadId, granularity);
         await this.raw.stepIn({ threadId, targetId, granularity });
@@ -636,9 +600,7 @@ let DebugSession = class DebugSession {
     async stepOut(threadId, granularity) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( (new Error(
-                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'stepOut')
-            )));
+            throw ( (new Error(localize(5755, "No debugger available, can not send '{0}'", 'stepOut'))));
         }
         this.setLastSteppingGranularity(threadId, granularity);
         await this.raw.stepOut({ threadId, granularity });
@@ -646,9 +608,7 @@ let DebugSession = class DebugSession {
     async stepBack(threadId, granularity) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( (new Error(
-                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'stepBack')
-            )));
+            throw ( (new Error(localize(5755, "No debugger available, can not send '{0}'", 'stepBack'))));
         }
         this.setLastSteppingGranularity(threadId, granularity);
         await this.raw.stepBack({ threadId, granularity });
@@ -656,78 +616,62 @@ let DebugSession = class DebugSession {
     async continue(threadId) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( (new Error(
-                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'continue')
-            )));
+            throw ( (new Error(localize(5755, "No debugger available, can not send '{0}'", 'continue'))));
         }
         await this.raw.continue({ threadId });
     }
     async reverseContinue(threadId) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( (new Error(localizeWithPath(
-                _moduleId,
-                0,
-                "No debugger available, can not send '{0}'",
-                'reverse continue'
-            ))));
+            throw ( (new Error(
+                localize(5755, "No debugger available, can not send '{0}'", 'reverse continue')
+            )));
         }
         await this.raw.reverseContinue({ threadId });
     }
     async pause(threadId) {
         if (!this.raw) {
-            throw ( (new Error(
-                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'pause')
-            )));
+            throw ( (new Error(localize(5755, "No debugger available, can not send '{0}'", 'pause'))));
         }
         await this.raw.pause({ threadId });
     }
     async terminateThreads(threadIds) {
         if (!this.raw) {
-            throw ( (new Error(localizeWithPath(
-                _moduleId,
-                0,
-                "No debugger available, can not send '{0}'",
-                'terminateThreads'
-            ))));
+            throw ( (new Error(
+                localize(5755, "No debugger available, can not send '{0}'", 'terminateThreads')
+            )));
         }
         await this.raw.terminateThreads({ threadIds });
     }
     setVariable(variablesReference, name, value) {
         if (!this.raw) {
-            throw ( (new Error(
-                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'setVariable')
-            )));
+            throw ( (new Error(localize(5755, "No debugger available, can not send '{0}'", 'setVariable'))));
         }
         return this.raw.setVariable({ variablesReference, name, value });
     }
     setExpression(frameId, expression, value) {
         if (!this.raw) {
             throw ( (new Error(
-                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'setExpression')
+                localize(5755, "No debugger available, can not send '{0}'", 'setExpression')
             )));
         }
         return this.raw.setExpression({ expression, value, frameId });
     }
     gotoTargets(source, line, column) {
         if (!this.raw) {
-            throw ( (new Error(
-                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'gotoTargets')
-            )));
+            throw ( (new Error(localize(5755, "No debugger available, can not send '{0}'", 'gotoTargets'))));
         }
         return this.raw.gotoTargets({ source, line, column });
     }
     goto(threadId, targetId) {
         if (!this.raw) {
-            throw ( (new Error(
-                localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'goto')
-            )));
+            throw ( (new Error(localize(5755, "No debugger available, can not send '{0}'", 'goto'))));
         }
         return this.raw.goto({ threadId, targetId });
     }
     loadSource(resource) {
         if (!this.raw) {
-            return Promise.reject(( (new Error(( localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'loadSource'))))));
+            return Promise.reject(( (new Error(( localize(5755, "No debugger available, can not send '{0}'", 'loadSource'))))));
         }
         const source = this.getSourceForUri(resource);
         let rawSource;
@@ -742,12 +686,7 @@ let DebugSession = class DebugSession {
     }
     async getLoadedSources() {
         if (!this.raw) {
-            return Promise.reject(( (new Error(( localizeWithPath(
-                _moduleId,
-                0,
-                "No debugger available, can not send '{0}'",
-                'getLoadedSources'
-            ))))));
+            return Promise.reject(( (new Error(( localize(5755, "No debugger available, can not send '{0}'", 'getLoadedSources'))))));
         }
         const response = await this.raw.loadedSources({});
         if (response?.body && response.body.sources) {
@@ -761,7 +700,7 @@ let DebugSession = class DebugSession {
     }
     async completions(frameId, threadId, text, position, overwriteBefore, token) {
         if (!this.raw) {
-            return Promise.reject(( (new Error(( localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'completions'))))));
+            return Promise.reject(( (new Error(( localize(5755, "No debugger available, can not send '{0}'", 'completions'))))));
         }
         const sessionCancelationToken = this.getNewCancellationToken(threadId, token);
         return this.raw.completions({
@@ -773,33 +712,33 @@ let DebugSession = class DebugSession {
     }
     async stepInTargets(frameId) {
         if (!this.raw) {
-            return Promise.reject(( (new Error(( localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'stepInTargets'))))));
+            return Promise.reject(( (new Error(( localize(5755, "No debugger available, can not send '{0}'", 'stepInTargets'))))));
         }
         const response = await this.raw.stepInTargets({ frameId });
         return response?.body.targets;
     }
     async cancel(progressId) {
         if (!this.raw) {
-            return Promise.reject(( (new Error(( localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'cancel'))))));
+            return Promise.reject(( (new Error(( localize(5755, "No debugger available, can not send '{0}'", 'cancel'))))));
         }
         return this.raw.cancel({ progressId });
     }
     async disassemble(memoryReference, offset, instructionOffset, instructionCount) {
         if (!this.raw) {
-            return Promise.reject(( (new Error(( localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'disassemble'))))));
+            return Promise.reject(( (new Error(( localize(5755, "No debugger available, can not send '{0}'", 'disassemble'))))));
         }
         const response = await this.raw.disassemble({ memoryReference, offset, instructionOffset, instructionCount, resolveSymbols: true });
         return response?.body?.instructions;
     }
     readMemory(memoryReference, offset, count) {
         if (!this.raw) {
-            return Promise.reject(( (new Error(( localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'readMemory'))))));
+            return Promise.reject(( (new Error(( localize(5755, "No debugger available, can not send '{0}'", 'readMemory'))))));
         }
         return this.raw.readMemory({ count, memoryReference, offset });
     }
     writeMemory(memoryReference, offset, data, allowPartial) {
         if (!this.raw) {
-            return Promise.reject(( (new Error(( localizeWithPath(_moduleId, 0, "No debugger available, can not send '{0}'", 'disassemble'))))));
+            return Promise.reject(( (new Error(( localize(5755, "No debugger available, can not send '{0}'", 'disassemble'))))));
         }
         return this.raw.writeMemory({ memoryReference, offset, allowPartial, data });
     }
@@ -910,8 +849,8 @@ let DebugSession = class DebugSession {
         }
         this.rawListeners.add(this.raw.onDidInitialize(async () => {
             status(this.configuration.noDebug
-                ? ( localizeWithPath(_moduleId, 3, "Started running without debugging."))
-                : ( localizeWithPath(_moduleId, 4, "Debugging started.")));
+                ? ( localize(5756, "Started running without debugging."))
+                : ( localize(5757, "Debugging started.")));
             const sendConfigurationDone = async () => {
                 if (this.raw && this.raw.capabilities.supportsConfigurationDoneRequest) {
                     try {
@@ -958,7 +897,7 @@ let DebugSession = class DebugSession {
             }
         }));
         this.rawListeners.add(this.raw.onDidTerminateDebugee(async (event) => {
-            status(( localizeWithPath(_moduleId, 5, "Debugging stopped.")));
+            status(( localize(5758, "Debugging stopped.")));
             if (event.body && event.body.restart) {
                 await this.debugService.restartSession(this, event.body.restart);
             }
@@ -1329,7 +1268,8 @@ DebugSession = ( (__decorate([
     ( (__param(17, IWorkbenchEnvironmentService))),
     ( (__param(18, ILogService))),
     ( (__param(19, ITestService))),
-    ( (__param(20, ITestResultService)))
+    ( (__param(20, ITestResultService))),
+    ( (__param(21, IAccessibilityService)))
 ], DebugSession)));
 class ThreadStatusScheduler extends Disposable {
     constructor() {

package/vscode/src/vs/workbench/contrib/debug/browser/debugSettingMigration.js

@@ -0,0 +1,19 @@
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/configuration';
+
+( Registry.as(Extensions.ConfigurationMigration))
+    .registerConfigurationMigrations([{
+        key: 'debug.autoExpandLazyVariables',
+        migrateFn: (value) => {
+            let newValue;
+            if (value === true) {
+                newValue = 'on';
+            }
+            else if (value === false) {
+                newValue = 'off';
+            }
+            return [
+                ['debug.autoExpandLazyVariables', { value: newValue }],
+            ];
+        }
+    }]);

package/vscode/src/vs/workbench/contrib/debug/browser/debugStatus.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { localize } from 'vscode/vscode/vs/nls';
 import { dispose } from 'vscode/vscode/vs/base/common/lifecycle';
 import { State } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
 import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug.service';
@@ -7,7 +7,6 @@ import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/c
 import { StatusbarAlignment } from 'vscode/vscode/vs/workbench/services/statusbar/browser/statusbar';
 import { IStatusbarService } from 'vscode/vscode/vs/workbench/services/statusbar/browser/statusbar.service';
 
-const _moduleId = "vs/workbench/contrib/debug/browser/debugStatus";
 let DebugStatusContribution = class DebugStatusContribution {
     constructor(statusBarService, debugService, configurationService) {
         this.statusBarService = statusBarService;
@@ -50,10 +49,10 @@ let DebugStatusContribution = class DebugStatusContribution {
             text = (manager.getLaunches().length > 1 ? `${name} (${manager.selectedConfiguration.launch.name})` : name);
         }
         return {
-            name: ( localizeWithPath(_moduleId, 0, "Debug")),
+            name: ( localize(6002, "Debug")),
             text: '$(debug-alt-small) ' + text,
-            ariaLabel: ( localizeWithPath(_moduleId, 1, "Debug: {0}", text)),
-            tooltip: ( localizeWithPath(_moduleId, 2, "Select and start debug configuration")),
+            ariaLabel: ( localize(6003, "Debug: {0}", text)),
+            tooltip: ( localize(6004, "Select and start debug configuration")),
             command: 'workbench.action.debug.selectandstart'
         };
     }