@codingame/monaco-vscode-debug-service-override 4.1.0 → 4.1.2

package/vscode/src/vs/workbench/contrib/debug/common/debugStorage.js

@@ -0,0 +1,166 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { observableValue } from 'vscode/vscode/vs/base/common/observableInternal/base';
+import 'vscode/vscode/vs/base/common/observableInternal/derived';
+import 'vscode/vscode/vs/base/common/observableInternal/autorun';
+import 'vscode/vscode/vs/base/common/observableInternal/utils';
+import 'vscode/vscode/vs/base/common/cancellation';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
+import { Breakpoint, FunctionBreakpoint, ExceptionBreakpoint, DataBreakpoint, Expression } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugModel';
+import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
+
+const DEBUG_BREAKPOINTS_KEY = 'debug.breakpoint';
+const DEBUG_FUNCTION_BREAKPOINTS_KEY = 'debug.functionbreakpoint';
+const DEBUG_DATA_BREAKPOINTS_KEY = 'debug.databreakpoint';
+const DEBUG_EXCEPTION_BREAKPOINTS_KEY = 'debug.exceptionbreakpoint';
+const DEBUG_WATCH_EXPRESSIONS_KEY = 'debug.watchexpressions';
+const DEBUG_CHOSEN_ENVIRONMENTS_KEY = 'debug.chosenenvironment';
+const DEBUG_UX_STATE_KEY = 'debug.uxstate';
+let DebugStorage = class DebugStorage extends Disposable {
+    constructor(storageService, textFileService, uriIdentityService, logService) {
+        super();
+        this.storageService = storageService;
+        this.textFileService = textFileService;
+        this.uriIdentityService = uriIdentityService;
+        this.logService = logService;
+        this.breakpoints = observableValue(this, this.loadBreakpoints());
+        this.functionBreakpoints = observableValue(this, this.loadFunctionBreakpoints());
+        this.exceptionBreakpoints = observableValue(this, this.loadExceptionBreakpoints());
+        this.dataBreakpoints = observableValue(this, this.loadDataBreakpoints());
+        this.watchExpressions = observableValue(this, this.loadWatchExpressions());
+        this._register(storageService.onDidChangeValue(1 , undefined, this._store)(e => {
+            if (e.external) {
+                switch (e.key) {
+                    case DEBUG_BREAKPOINTS_KEY:
+                        return this.breakpoints.set(this.loadBreakpoints(), undefined);
+                    case DEBUG_FUNCTION_BREAKPOINTS_KEY:
+                        return this.functionBreakpoints.set(this.loadFunctionBreakpoints(), undefined);
+                    case DEBUG_EXCEPTION_BREAKPOINTS_KEY:
+                        return this.exceptionBreakpoints.set(this.loadExceptionBreakpoints(), undefined);
+                    case DEBUG_DATA_BREAKPOINTS_KEY:
+                        return this.dataBreakpoints.set(this.loadDataBreakpoints(), undefined);
+                    case DEBUG_WATCH_EXPRESSIONS_KEY:
+                        return this.watchExpressions.set(this.loadWatchExpressions(), undefined);
+                }
+            }
+        }));
+    }
+    loadDebugUxState() {
+        return this.storageService.get(DEBUG_UX_STATE_KEY, 1 , 'default');
+    }
+    storeDebugUxState(value) {
+        this.storageService.store(DEBUG_UX_STATE_KEY, value, 1 , 1 );
+    }
+    loadBreakpoints() {
+        let result;
+        try {
+            result = ( JSON.parse(this.storageService.get(DEBUG_BREAKPOINTS_KEY, 1 , '[]')).map((breakpoint) => {
+                breakpoint.uri = URI.revive(breakpoint.uri);
+                return ( new Breakpoint(
+                    breakpoint,
+                    this.textFileService,
+                    this.uriIdentityService,
+                    this.logService,
+                    breakpoint.id
+                ));
+            }));
+        }
+        catch (e) { }
+        return result || [];
+    }
+    loadFunctionBreakpoints() {
+        let result;
+        try {
+            result = ( JSON.parse(this.storageService.get(DEBUG_FUNCTION_BREAKPOINTS_KEY, 1 , '[]')).map((fb) => {
+                return ( new FunctionBreakpoint(fb, fb.id));
+            }));
+        }
+        catch (e) { }
+        return result || [];
+    }
+    loadExceptionBreakpoints() {
+        let result;
+        try {
+            result = ( JSON.parse(this.storageService.get(DEBUG_EXCEPTION_BREAKPOINTS_KEY, 1 , '[]')).map((exBreakpoint) => {
+                return ( new ExceptionBreakpoint(exBreakpoint, exBreakpoint.id));
+            }));
+        }
+        catch (e) { }
+        return result || [];
+    }
+    loadDataBreakpoints() {
+        let result;
+        try {
+            result = ( JSON.parse(this.storageService.get(DEBUG_DATA_BREAKPOINTS_KEY, 1 , '[]')).map((dbp) => {
+                return ( new DataBreakpoint(dbp, dbp.id));
+            }));
+        }
+        catch (e) { }
+        return result || [];
+    }
+    loadWatchExpressions() {
+        let result;
+        try {
+            result = ( JSON.parse(this.storageService.get(DEBUG_WATCH_EXPRESSIONS_KEY, 1 , '[]')).map((watchStoredData) => {
+                return ( new Expression(watchStoredData.name, watchStoredData.id));
+            }));
+        }
+        catch (e) { }
+        return result || [];
+    }
+    loadChosenEnvironments() {
+        return JSON.parse(this.storageService.get(DEBUG_CHOSEN_ENVIRONMENTS_KEY, 1 , '{}'));
+    }
+    storeChosenEnvironments(environments) {
+        this.storageService.store(DEBUG_CHOSEN_ENVIRONMENTS_KEY, JSON.stringify(environments), 1 , 1 );
+    }
+    storeWatchExpressions(watchExpressions) {
+        if (watchExpressions.length) {
+            this.storageService.store(DEBUG_WATCH_EXPRESSIONS_KEY, JSON.stringify(( watchExpressions.map(we => ({ name: we.name, id: we.getId() })))), 1 , 1 );
+        }
+        else {
+            this.storageService.remove(DEBUG_WATCH_EXPRESSIONS_KEY, 1 );
+        }
+    }
+    storeBreakpoints(debugModel) {
+        const breakpoints = debugModel.getBreakpoints();
+        if (breakpoints.length) {
+            this.storageService.store(DEBUG_BREAKPOINTS_KEY, JSON.stringify(breakpoints), 1 , 1 );
+        }
+        else {
+            this.storageService.remove(DEBUG_BREAKPOINTS_KEY, 1 );
+        }
+        const functionBreakpoints = debugModel.getFunctionBreakpoints();
+        if (functionBreakpoints.length) {
+            this.storageService.store(DEBUG_FUNCTION_BREAKPOINTS_KEY, JSON.stringify(functionBreakpoints), 1 , 1 );
+        }
+        else {
+            this.storageService.remove(DEBUG_FUNCTION_BREAKPOINTS_KEY, 1 );
+        }
+        const dataBreakpoints = debugModel.getDataBreakpoints().filter(dbp => dbp.canPersist);
+        if (dataBreakpoints.length) {
+            this.storageService.store(DEBUG_DATA_BREAKPOINTS_KEY, JSON.stringify(dataBreakpoints), 1 , 1 );
+        }
+        else {
+            this.storageService.remove(DEBUG_DATA_BREAKPOINTS_KEY, 1 );
+        }
+        const exceptionBreakpoints = debugModel.getExceptionBreakpoints();
+        if (exceptionBreakpoints.length) {
+            this.storageService.store(DEBUG_EXCEPTION_BREAKPOINTS_KEY, JSON.stringify(exceptionBreakpoints), 1 , 1 );
+        }
+        else {
+            this.storageService.remove(DEBUG_EXCEPTION_BREAKPOINTS_KEY, 1 );
+        }
+    }
+};
+DebugStorage = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, ITextFileService)),
+    ( __param(2, IUriIdentityService)),
+    ( __param(3, ILogService))
+], DebugStorage));
+
+export { DebugStorage };

package/vscode/src/vs/workbench/contrib/debug/common/debugTelemetry.js

@@ -0,0 +1,36 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+
+let DebugTelemetry = class DebugTelemetry {
+    constructor(model, telemetryService) {
+        this.model = model;
+        this.telemetryService = telemetryService;
+    }
+    logDebugSessionStart(dbgr, launchJsonExists) {
+        const extension = dbgr.getMainExtensionDescriptor();
+        this.telemetryService.publicLog('debugSessionStart', {
+            type: dbgr.type,
+            breakpointCount: this.model.getBreakpoints().length,
+            exceptionBreakpoints: this.model.getExceptionBreakpoints(),
+            watchExpressionsCount: this.model.getWatchExpressions().length,
+            extensionName: extension.identifier.value,
+            isBuiltin: extension.isBuiltin,
+            launchJsonExists
+        });
+    }
+    logDebugSessionStop(session, adapterExitEvent) {
+        const breakpoints = this.model.getBreakpoints();
+        this.telemetryService.publicLog('debugSessionStop', {
+            type: session && session.configuration.type,
+            success: adapterExitEvent.emittedStopped || breakpoints.length === 0,
+            sessionLengthInSeconds: adapterExitEvent.sessionLengthInSeconds,
+            breakpointCount: breakpoints.length,
+            watchExpressionsCount: this.model.getWatchExpressions().length
+        });
+    }
+};
+DebugTelemetry = ( __decorate([
+    ( __param(1, ITelemetryService))
+], DebugTelemetry));
+
+export { DebugTelemetry };

package/vscode/src/vs/workbench/contrib/debug/common/debugViewModel.js

@@ -0,0 +1,150 @@
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { CONTEXT_EXPRESSION_SELECTED, CONTEXT_LOADED_SCRIPTS_SUPPORTED, CONTEXT_STEP_BACK_SUPPORTED, CONTEXT_FOCUSED_SESSION_IS_ATTACH, CONTEXT_FOCUSED_SESSION_IS_NO_DEBUG, CONTEXT_RESTART_FRAME_SUPPORTED, CONTEXT_STEP_INTO_TARGETS_SUPPORTED, CONTEXT_JUMP_TO_CURSOR_SUPPORTED, CONTEXT_SET_VARIABLE_SUPPORTED, CONTEXT_SET_DATA_BREAKPOINT_BYTES_SUPPORTED, CONTEXT_SET_EXPRESSION_SUPPORTED, CONTEXT_MULTI_SESSION_DEBUG, CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED, CONTEXT_SUSPEND_DEBUGGEE_SUPPORTED, CONTEXT_DISASSEMBLE_REQUEST_SUPPORTED, CONTEXT_FOCUSED_STACK_FRAME_HAS_INSTRUCTION_POINTER_REFERENCE } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { isSessionAttach } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugUtils';
+
+class ViewModel {
+    constructor(contextKeyService) {
+        this.contextKeyService = contextKeyService;
+        this.firstSessionStart = true;
+        this._onDidFocusSession = ( new Emitter());
+        this._onDidFocusThread = ( new Emitter());
+        this._onDidFocusStackFrame = ( new Emitter());
+        this._onDidSelectExpression = ( new Emitter());
+        this._onDidEvaluateLazyExpression = ( new Emitter());
+        this._onWillUpdateViews = ( new Emitter());
+        this._onDidChangeVisualization = ( new Emitter());
+        this.visualized = ( new WeakMap());
+        this.preferredVisualizers = ( new Map());
+        contextKeyService.bufferChangeEvents(() => {
+            this.expressionSelectedContextKey = CONTEXT_EXPRESSION_SELECTED.bindTo(contextKeyService);
+            this.loadedScriptsSupportedContextKey = CONTEXT_LOADED_SCRIPTS_SUPPORTED.bindTo(contextKeyService);
+            this.stepBackSupportedContextKey = CONTEXT_STEP_BACK_SUPPORTED.bindTo(contextKeyService);
+            this.focusedSessionIsAttach = CONTEXT_FOCUSED_SESSION_IS_ATTACH.bindTo(contextKeyService);
+            this.focusedSessionIsNoDebug = CONTEXT_FOCUSED_SESSION_IS_NO_DEBUG.bindTo(contextKeyService);
+            this.restartFrameSupportedContextKey = CONTEXT_RESTART_FRAME_SUPPORTED.bindTo(contextKeyService);
+            this.stepIntoTargetsSupported = CONTEXT_STEP_INTO_TARGETS_SUPPORTED.bindTo(contextKeyService);
+            this.jumpToCursorSupported = CONTEXT_JUMP_TO_CURSOR_SUPPORTED.bindTo(contextKeyService);
+            this.setVariableSupported = CONTEXT_SET_VARIABLE_SUPPORTED.bindTo(contextKeyService);
+            this.setDataBreakpointAtByteSupported = CONTEXT_SET_DATA_BREAKPOINT_BYTES_SUPPORTED.bindTo(contextKeyService);
+            this.setExpressionSupported = CONTEXT_SET_EXPRESSION_SUPPORTED.bindTo(contextKeyService);
+            this.multiSessionDebug = CONTEXT_MULTI_SESSION_DEBUG.bindTo(contextKeyService);
+            this.terminateDebuggeeSupported = CONTEXT_TERMINATE_DEBUGGEE_SUPPORTED.bindTo(contextKeyService);
+            this.suspendDebuggeeSupported = CONTEXT_SUSPEND_DEBUGGEE_SUPPORTED.bindTo(contextKeyService);
+            this.disassembleRequestSupported = CONTEXT_DISASSEMBLE_REQUEST_SUPPORTED.bindTo(contextKeyService);
+            this.focusedStackFrameHasInstructionPointerReference = CONTEXT_FOCUSED_STACK_FRAME_HAS_INSTRUCTION_POINTER_REFERENCE.bindTo(contextKeyService);
+        });
+    }
+    getId() {
+        return 'root';
+    }
+    get focusedSession() {
+        return this._focusedSession;
+    }
+    get focusedThread() {
+        return this._focusedThread;
+    }
+    get focusedStackFrame() {
+        return this._focusedStackFrame;
+    }
+    setFocus(stackFrame, thread, session, explicit) {
+        const shouldEmitForStackFrame = this._focusedStackFrame !== stackFrame;
+        const shouldEmitForSession = this._focusedSession !== session;
+        const shouldEmitForThread = this._focusedThread !== thread;
+        this._focusedStackFrame = stackFrame;
+        this._focusedThread = thread;
+        this._focusedSession = session;
+        this.contextKeyService.bufferChangeEvents(() => {
+            this.loadedScriptsSupportedContextKey.set(!!session?.capabilities.supportsLoadedSourcesRequest);
+            this.stepBackSupportedContextKey.set(!!session?.capabilities.supportsStepBack);
+            this.restartFrameSupportedContextKey.set(!!session?.capabilities.supportsRestartFrame);
+            this.stepIntoTargetsSupported.set(!!session?.capabilities.supportsStepInTargetsRequest);
+            this.jumpToCursorSupported.set(!!session?.capabilities.supportsGotoTargetsRequest);
+            this.setVariableSupported.set(!!session?.capabilities.supportsSetVariable);
+            this.setDataBreakpointAtByteSupported.set(!!session?.capabilities.supportsDataBreakpointBytes);
+            this.setExpressionSupported.set(!!session?.capabilities.supportsSetExpression);
+            this.terminateDebuggeeSupported.set(!!session?.capabilities.supportTerminateDebuggee);
+            this.suspendDebuggeeSupported.set(!!session?.capabilities.supportSuspendDebuggee);
+            this.disassembleRequestSupported.set(!!session?.capabilities.supportsDisassembleRequest);
+            this.focusedStackFrameHasInstructionPointerReference.set(!!stackFrame?.instructionPointerReference);
+            const attach = !!session && isSessionAttach(session);
+            this.focusedSessionIsAttach.set(attach);
+            this.focusedSessionIsNoDebug.set(!!session && !!session.configuration.noDebug);
+        });
+        if (shouldEmitForSession) {
+            this._onDidFocusSession.fire(session);
+        }
+        if (shouldEmitForStackFrame) {
+            this._onDidFocusStackFrame.fire({ stackFrame, explicit, session });
+        }
+        else if (shouldEmitForThread) {
+            this._onDidFocusThread.fire({ thread, explicit, session });
+        }
+    }
+    get onDidFocusSession() {
+        return this._onDidFocusSession.event;
+    }
+    get onDidFocusThread() {
+        return this._onDidFocusThread.event;
+    }
+    get onDidFocusStackFrame() {
+        return this._onDidFocusStackFrame.event;
+    }
+    get onDidChangeVisualization() {
+        return this._onDidChangeVisualization.event;
+    }
+    getSelectedExpression() {
+        return this.selectedExpression;
+    }
+    setSelectedExpression(expression, settingWatch) {
+        this.selectedExpression = expression ? { expression, settingWatch: settingWatch } : undefined;
+        this.expressionSelectedContextKey.set(!!expression);
+        this._onDidSelectExpression.fire(this.selectedExpression);
+    }
+    get onDidSelectExpression() {
+        return this._onDidSelectExpression.event;
+    }
+    get onDidEvaluateLazyExpression() {
+        return this._onDidEvaluateLazyExpression.event;
+    }
+    updateViews() {
+        this._onWillUpdateViews.fire();
+    }
+    get onWillUpdateViews() {
+        return this._onWillUpdateViews.event;
+    }
+    isMultiSessionView() {
+        return !!this.multiSessionDebug.get();
+    }
+    setMultiSessionView(isMultiSessionView) {
+        this.multiSessionDebug.set(isMultiSessionView);
+    }
+    setVisualizedExpression(original, visualized) {
+        const current = this.visualized.get(original) || original;
+        const key = this.getPreferredVisualizedKey(original);
+        if (visualized) {
+            this.visualized.set(original, visualized);
+            this.preferredVisualizers.set(key, visualized.treeId);
+        }
+        else {
+            this.visualized.delete(original);
+            this.preferredVisualizers.delete(key);
+        }
+        this._onDidChangeVisualization.fire({ original: current, replacement: visualized || original });
+    }
+    getVisualizedExpression(expression) {
+        return this.visualized.get(expression) || this.preferredVisualizers.get(this.getPreferredVisualizedKey(expression));
+    }
+    async evaluateLazyExpression(expression) {
+        await expression.evaluateLazy();
+        this._onDidEvaluateLazyExpression.fire(expression);
+    }
+    getPreferredVisualizedKey(expr) {
+        return JSON.stringify([
+            expr.name,
+            expr.type,
+            !!expr.memoryReference,
+        ].join('\0'));
+    }
+}
+
+export { ViewModel };

package/vscode/src/vs/workbench/contrib/debug/common/debugger.js

@@ -0,0 +1,289 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { isObject } from 'vscode/vscode/vs/base/common/types';
+import { DebugConfigurationProviderTriggerKind, debuggerDisabledMessage, IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { IConfigurationResolverService } from 'vscode/vscode/vs/workbench/services/configurationResolver/common/configurationResolver';
+import { applyDeprecatedVariableMessage } from 'vscode/vscode/vs/workbench/services/configurationResolver/common/configurationResolverUtils';
+import { ITextResourcePropertiesService } from 'vscode/vscode/vs/editor/common/services/textResourceConfiguration';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { isDebuggerMainContribution } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugUtils';
+import { cleanRemoteAuthority } from 'vscode/vscode/vs/platform/telemetry/common/telemetryUtils';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { ContextKeyExpr, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { filter } from 'vscode/vscode/vs/base/common/objects';
+
+let Debugger = class Debugger {
+    constructor(adapterManager, dbgContribution, extensionDescription, configurationService, resourcePropertiesService, configurationResolverService, environmentService, debugService, contextKeyService) {
+        this.adapterManager = adapterManager;
+        this.configurationService = configurationService;
+        this.resourcePropertiesService = resourcePropertiesService;
+        this.configurationResolverService = configurationResolverService;
+        this.environmentService = environmentService;
+        this.debugService = debugService;
+        this.contextKeyService = contextKeyService;
+        this.mergedExtensionDescriptions = [];
+        this.debuggerContribution = { type: dbgContribution.type };
+        this.merge(dbgContribution, extensionDescription);
+        this.debuggerWhen = typeof this.debuggerContribution.when === 'string' ? ContextKeyExpr.deserialize(this.debuggerContribution.when) : undefined;
+        this.debuggerHiddenWhen = typeof this.debuggerContribution.hiddenWhen === 'string' ? ContextKeyExpr.deserialize(this.debuggerContribution.hiddenWhen) : undefined;
+    }
+    merge(otherDebuggerContribution, extensionDescription) {
+        function mixin(destination, source, overwrite, level = 0) {
+            if (!isObject(destination)) {
+                return source;
+            }
+            if (isObject(source)) {
+                ( Object.keys(source)).forEach(key => {
+                    if (key !== '__proto__') {
+                        if (isObject(destination[key]) && isObject(source[key])) {
+                            mixin(destination[key], source[key], overwrite, level + 1);
+                        }
+                        else {
+                            if (key in destination) {
+                                if (overwrite) {
+                                    if (level === 0 && key === 'type') ;
+                                    else {
+                                        destination[key] = source[key];
+                                    }
+                                }
+                            }
+                            else {
+                                destination[key] = source[key];
+                            }
+                        }
+                    }
+                });
+            }
+            return destination;
+        }
+        if (this.mergedExtensionDescriptions.indexOf(extensionDescription) < 0) {
+            this.mergedExtensionDescriptions.push(extensionDescription);
+            mixin(this.debuggerContribution, otherDebuggerContribution, extensionDescription.isBuiltin);
+            if (isDebuggerMainContribution(otherDebuggerContribution)) {
+                this.mainExtensionDescription = extensionDescription;
+            }
+        }
+    }
+    async startDebugging(configuration, parentSessionId) {
+        const parentSession = this.debugService.getModel().getSession(parentSessionId);
+        return await this.debugService.startDebugging(undefined, configuration, { parentSession }, undefined);
+    }
+    async createDebugAdapter(session) {
+        await this.adapterManager.activateDebuggers('onDebugAdapterProtocolTracker', this.type);
+        const da = this.adapterManager.createDebugAdapter(session);
+        if (da) {
+            return Promise.resolve(da);
+        }
+        throw new Error(localizeWithPath('vs/workbench/contrib/debug/common/debugger', 'cannot.find.da', "Cannot find debug adapter for type '{0}'.", this.type));
+    }
+    async substituteVariables(folder, config) {
+        const substitutedConfig = await this.adapterManager.substituteVariables(this.type, folder, config);
+        return await this.configurationResolverService.resolveWithInteractionReplace(folder, substitutedConfig, 'launch', this.variables, substitutedConfig.__configurationTarget);
+    }
+    runInTerminal(args, sessionId) {
+        return this.adapterManager.runInTerminal(this.type, args, sessionId);
+    }
+    get label() {
+        return this.debuggerContribution.label || this.debuggerContribution.type;
+    }
+    get type() {
+        return this.debuggerContribution.type;
+    }
+    get variables() {
+        return this.debuggerContribution.variables;
+    }
+    get configurationSnippets() {
+        return this.debuggerContribution.configurationSnippets;
+    }
+    get languages() {
+        return this.debuggerContribution.languages;
+    }
+    get when() {
+        return this.debuggerWhen;
+    }
+    get hiddenWhen() {
+        return this.debuggerHiddenWhen;
+    }
+    get enabled() {
+        return !this.debuggerWhen || this.contextKeyService.contextMatchesRules(this.debuggerWhen);
+    }
+    get isHiddenFromDropdown() {
+        if (!this.debuggerHiddenWhen) {
+            return false;
+        }
+        return this.contextKeyService.contextMatchesRules(this.debuggerHiddenWhen);
+    }
+    get strings() {
+        return this.debuggerContribution.strings ?? this.debuggerContribution.uiMessages;
+    }
+    interestedInLanguage(languageId) {
+        return !!(this.languages && this.languages.indexOf(languageId) >= 0);
+    }
+    hasInitialConfiguration() {
+        return !!this.debuggerContribution.initialConfigurations;
+    }
+    hasDynamicConfigurationProviders() {
+        return this.debugService.getConfigurationManager().hasDebugConfigurationProvider(this.type, DebugConfigurationProviderTriggerKind.Dynamic);
+    }
+    hasConfigurationProvider() {
+        return this.debugService.getConfigurationManager().hasDebugConfigurationProvider(this.type);
+    }
+    getInitialConfigurationContent(initialConfigs) {
+        let initialConfigurations = this.debuggerContribution.initialConfigurations || [];
+        if (initialConfigs) {
+            initialConfigurations = initialConfigurations.concat(initialConfigs);
+        }
+        const eol = this.resourcePropertiesService.getEOL(( URI.from({ scheme: Schemas.untitled, path: '1' }))) === '\r\n' ? '\r\n' : '\n';
+        const configs = ( JSON.stringify(initialConfigurations, null, '\t').split('\n').map(line => '\t' + line)).join(eol).trim();
+        const comment1 = ( localizeWithPath(
+            'vs/workbench/contrib/debug/common/debugger',
+            'launch.config.comment1',
+            "Use IntelliSense to learn about possible attributes."
+        ));
+        const comment2 = ( localizeWithPath(
+            'vs/workbench/contrib/debug/common/debugger',
+            'launch.config.comment2',
+            "Hover to view descriptions of existing attributes."
+        ));
+        const comment3 = ( localizeWithPath(
+            'vs/workbench/contrib/debug/common/debugger',
+            'launch.config.comment3',
+            "For more information, visit: {0}",
+            'https://go.microsoft.com/fwlink/?linkid=830387'
+        ));
+        let content = [
+            '{',
+            `\t// ${comment1}`,
+            `\t// ${comment2}`,
+            `\t// ${comment3}`,
+            `\t"version": "0.2.0",`,
+            `\t"configurations": ${configs}`,
+            '}'
+        ].join(eol);
+        const editorConfig = this.configurationService.getValue();
+        if (editorConfig.editor && editorConfig.editor.insertSpaces) {
+            content = content.replace(( new RegExp('\t', 'g')), ' '.repeat(editorConfig.editor.tabSize));
+        }
+        return Promise.resolve(content);
+    }
+    getMainExtensionDescriptor() {
+        return this.mainExtensionDescription || this.mergedExtensionDescriptions[0];
+    }
+    getCustomTelemetryEndpoint() {
+        const aiKey = this.debuggerContribution.aiKey;
+        if (!aiKey) {
+            return undefined;
+        }
+        const sendErrorTelemtry = cleanRemoteAuthority(this.environmentService.remoteAuthority) !== 'other';
+        return {
+            id: `${this.getMainExtensionDescriptor().publisher}.${this.type}`,
+            aiKey,
+            sendErrorTelemetry: sendErrorTelemtry
+        };
+    }
+    getSchemaAttributes(definitions) {
+        if (!this.debuggerContribution.configurationAttributes) {
+            return null;
+        }
+        return ( ( Object.keys(this.debuggerContribution.configurationAttributes)).map(request => {
+            const definitionId = `${this.type}:${request}`;
+            const platformSpecificDefinitionId = `${this.type}:${request}:platform`;
+            const attributes = this.debuggerContribution.configurationAttributes[request];
+            const defaultRequired = ['name', 'type', 'request'];
+            attributes.required = attributes.required && attributes.required.length ? defaultRequired.concat(attributes.required) : defaultRequired;
+            attributes.additionalProperties = false;
+            attributes.type = 'object';
+            if (!attributes.properties) {
+                attributes.properties = {};
+            }
+            const properties = attributes.properties;
+            properties['type'] = {
+                enum: [this.type],
+                enumDescriptions: [this.label],
+                description: ( localizeWithPath(
+                    'vs/workbench/contrib/debug/common/debugger',
+                    'debugType',
+                    "Type of configuration."
+                )),
+                pattern: '^(?!node2)',
+                deprecationMessage: this.debuggerContribution.deprecated || (this.enabled ? undefined : debuggerDisabledMessage(this.type)),
+                doNotSuggest: !!this.debuggerContribution.deprecated,
+                errorMessage: ( localizeWithPath(
+                    'vs/workbench/contrib/debug/common/debugger',
+                    'debugTypeNotRecognised',
+                    "The debug type is not recognized. Make sure that you have a corresponding debug extension installed and that it is enabled."
+                )),
+                patternErrorMessage: ( localizeWithPath(
+                    'vs/workbench/contrib/debug/common/debugger',
+                    'node2NotSupported',
+                    "\"node2\" is no longer supported, use \"node\" instead and set the \"protocol\" attribute to \"inspector\"."
+                ))
+            };
+            properties['request'] = {
+                enum: [request],
+                description: ( localizeWithPath(
+                    'vs/workbench/contrib/debug/common/debugger',
+                    'debugRequest',
+                    "Request type of configuration. Can be \"launch\" or \"attach\"."
+                )),
+            };
+            for (const prop in definitions['common'].properties) {
+                properties[prop] = {
+                    $ref: `#/definitions/common/properties/${prop}`
+                };
+            }
+            ( Object.keys(properties)).forEach(name => {
+                applyDeprecatedVariableMessage(properties[name]);
+            });
+            definitions[definitionId] = { ...attributes };
+            definitions[platformSpecificDefinitionId] = {
+                type: 'object',
+                additionalProperties: false,
+                properties: filter(properties, key => key !== 'type' && key !== 'request' && key !== 'name')
+            };
+            const attributesCopy = { ...attributes };
+            attributesCopy.properties = {
+                ...properties,
+                ...{
+                    windows: {
+                        $ref: `#/definitions/${platformSpecificDefinitionId}`,
+                        description: ( localizeWithPath(
+                            'vs/workbench/contrib/debug/common/debugger',
+                            'debugWindowsConfiguration',
+                            "Windows specific launch configuration attributes."
+                        )),
+                    },
+                    osx: {
+                        $ref: `#/definitions/${platformSpecificDefinitionId}`,
+                        description: ( localizeWithPath(
+                            'vs/workbench/contrib/debug/common/debugger',
+                            'debugOSXConfiguration',
+                            "OS X specific launch configuration attributes."
+                        )),
+                    },
+                    linux: {
+                        $ref: `#/definitions/${platformSpecificDefinitionId}`,
+                        description: ( localizeWithPath(
+                            'vs/workbench/contrib/debug/common/debugger',
+                            'debugLinuxConfiguration',
+                            "Linux specific launch configuration attributes."
+                        )),
+                    }
+                }
+            };
+            return attributesCopy;
+        }));
+    }
+};
+Debugger = ( __decorate([
+    ( __param(3, IConfigurationService)),
+    ( __param(4, ITextResourcePropertiesService)),
+    ( __param(5, IConfigurationResolverService)),
+    ( __param(6, IWorkbenchEnvironmentService)),
+    ( __param(7, IDebugService)),
+    ( __param(8, IContextKeyService))
+], Debugger));
+
+export { Debugger };