@codingame/monaco-vscode-api 4.1.0 → 4.1.1

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

@@ -1,164 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable } from '../../../../base/common/lifecycle.js';
-import { observableValue } from '../../../../base/common/observableInternal/base.js';
-import '../../../../base/common/observableInternal/derived.js';
-import '../../../../base/common/observableInternal/autorun.js';
-import '../../../../base/common/observableInternal/utils.js';
-import '../../../../base/common/cancellation.js';
-import { URI } from '../../../../base/common/uri.js';
-import { ILogService } from '../../../../platform/log/common/log.js';
-import { IStorageService } from '../../../../platform/storage/common/storage.js';
-import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
-import { Breakpoint, FunctionBreakpoint, ExceptionBreakpoint, DataBreakpoint, Expression } from './debugModel.js';
-import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
-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

@@ -1,34 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
-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

@@ -1,148 +0,0 @@
-import { Emitter } from '../../../../base/common/event.js';
-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 './debug.js';
-import { isSessionAttach } from './debugUtils.js';
-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

@@ -1,287 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from '../../../../nls.js';
-import { isObject } from '../../../../base/common/types.js';
-import { DebugConfigurationProviderTriggerKind, debuggerDisabledMessage, IDebugService } from './debug.js';
-import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
-import { IConfigurationResolverService } from '../../../services/configurationResolver/common/configurationResolver.js';
-import { applyDeprecatedVariableMessage } from '../../../services/configurationResolver/common/configurationResolverUtils.js';
-import { ITextResourcePropertiesService } from '../../../../editor/common/services/textResourceConfiguration.js';
-import { URI } from '../../../../base/common/uri.js';
-import { Schemas } from '../../../../base/common/network.js';
-import { isDebuggerMainContribution } from './debugUtils.js';
-import { cleanRemoteAuthority } from '../../../../platform/telemetry/common/telemetryUtils.js';
-import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
-import { ContextKeyExpr, IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
-import { filter } from '../../../../base/common/objects.js';
-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 };