@codingame/monaco-vscode-api 1.78.4 → 1.78.5-next.0

package/dist/vscode/vs/workbench/contrib/debug/common/debugUtils.js

@@ -0,0 +1,292 @@
+import { equalsIgnoreCase } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { isAbsolute } from 'monaco-editor/esm/vs/base/common/path.js';
+import { deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
+const _formatPIIRegexp = /{([^}]+)}/g;
+function formatPII(value, excludePII, args) {
+    return value.replace(_formatPIIRegexp, function (match, group) {
+        if (excludePII && group.length > 0 && group[0] !== '_') {
+            return match;
+        }
+        return args && args.hasOwnProperty(group) ?
+            args[group] :
+            match;
+    });
+}
+function filterExceptionsFromTelemetry(data) {
+    const output = {};
+    for (const key of ( (Object.keys(data)))) {
+        if (!key.startsWith('!')) {
+            output[key] = data[key];
+        }
+    }
+    return output;
+}
+function isSessionAttach(session) {
+    return session.configuration.request === 'attach' && !getExtensionHostDebugSession(session) && (!session.parentSession || isSessionAttach(session.parentSession));
+}
+function getExtensionHostDebugSession(session) {
+    let type = session.configuration.type;
+    if (!type) {
+        return;
+    }
+    if (type === 'vslsShare') {
+        type = session.configuration.adapterProxy.configuration.type;
+    }
+    if (equalsIgnoreCase(type, 'extensionhost') || equalsIgnoreCase(type, 'pwa-extensionhost')) {
+        return session;
+    }
+    return session.parentSession ? getExtensionHostDebugSession(session.parentSession) : undefined;
+}
+function isDebuggerMainContribution(dbg) {
+    return dbg.type && (dbg.label || dbg.program || dbg.runtime);
+}
+function getExactExpressionStartAndEnd(lineContent, looseStart, looseEnd) {
+    let matchingExpression = undefined;
+    let startOffset = 0;
+    const expression = /([^()\[\]{}<>\s+\-/%~#^;=|,`!]|\->)+/g;
+    let result = null;
+    while (result = expression.exec(lineContent)) {
+        const start = result.index + 1;
+        const end = start + result[0].length;
+        if (start <= looseStart && end >= looseEnd) {
+            matchingExpression = result[0];
+            startOffset = start;
+            break;
+        }
+    }
+    if (matchingExpression) {
+        const subExpression = /\w+/g;
+        let subExpressionResult = null;
+        while (subExpressionResult = subExpression.exec(matchingExpression)) {
+            const subEnd = subExpressionResult.index + 1 + startOffset + subExpressionResult[0].length;
+            if (subEnd >= looseEnd) {
+                break;
+            }
+        }
+        if (subExpressionResult) {
+            matchingExpression = matchingExpression.substring(0, subExpression.lastIndex);
+        }
+    }
+    return matchingExpression ?
+        { start: startOffset, end: startOffset + matchingExpression.length - 1 } :
+        { start: 0, end: 0 };
+}
+async function getEvaluatableExpressionAtPosition(languageFeaturesService, model, position, token) {
+    if (languageFeaturesService.evaluatableExpressionProvider.has(model)) {
+        const supports = languageFeaturesService.evaluatableExpressionProvider.ordered(model);
+        const results = coalesce(await Promise.all(( (supports.map(async (support) => {
+            try {
+                return await support.provideEvaluatableExpression(model, position, token ?? CancellationToken.None);
+            }
+            catch (err) {
+                return undefined;
+            }
+        })))));
+        if (results.length > 0) {
+            let matchingExpression = results[0].expression;
+            const range = results[0].range;
+            if (!matchingExpression) {
+                const lineContent = model.getLineContent(position.lineNumber);
+                matchingExpression = lineContent.substring(range.startColumn - 1, range.endColumn - 1);
+            }
+            return { range, matchingExpression };
+        }
+    }
+    else {
+        const lineContent = model.getLineContent(position.lineNumber);
+        const { start, end } = getExactExpressionStartAndEnd(lineContent, position.column, position.column);
+        const matchingExpression = lineContent.substring(start - 1, end);
+        return {
+            matchingExpression,
+            range: ( (new Range(
+                position.lineNumber,
+                start,
+                position.lineNumber,
+                start + matchingExpression.length
+            )))
+        };
+    }
+    return null;
+}
+const _schemePattern = /^[a-zA-Z][a-zA-Z0-9\+\-\.]+:/;
+function isUri(s) {
+    return !!(s && s.match(_schemePattern));
+}
+function stringToUri(source) {
+    if (typeof source.path === 'string') {
+        if (typeof source.sourceReference === 'number' && source.sourceReference > 0) ;
+        else {
+            if (isUri(source.path)) {
+                return ( URI.parse(source.path));
+            }
+            else {
+                if (isAbsolute(source.path)) {
+                    return URI.file(source.path);
+                }
+            }
+        }
+    }
+    return source.path;
+}
+function uriToString(source) {
+    if (typeof source.path === 'object') {
+        const u = URI.revive(source.path);
+        if (u) {
+            if (u.scheme === Schemas.file) {
+                return u.fsPath;
+            }
+            else {
+                return (
+                     (u.toString())
+                );
+            }
+        }
+    }
+    return source.path;
+}
+function convertToDAPaths(message, toUri) {
+    const fixPath = toUri ? stringToUri : uriToString;
+    const msg = deepClone(message);
+    convertPaths(msg, (toDA, source) => {
+        if (toDA && source) {
+            source.path = fixPath(source);
+        }
+    });
+    return msg;
+}
+function convertToVSCPaths(message, toUri) {
+    const fixPath = toUri ? stringToUri : uriToString;
+    const msg = deepClone(message);
+    convertPaths(msg, (toDA, source) => {
+        if (!toDA && source) {
+            source.path = fixPath(source);
+        }
+    });
+    return msg;
+}
+function convertPaths(msg, fixSourcePath) {
+    switch (msg.type) {
+        case 'event': {
+            const event = msg;
+            switch (event.event) {
+                case 'output':
+                    fixSourcePath(false, event.body.source);
+                    break;
+                case 'loadedSource':
+                    fixSourcePath(false, event.body.source);
+                    break;
+                case 'breakpoint':
+                    fixSourcePath(false, event.body.breakpoint.source);
+                    break;
+            }
+            break;
+        }
+        case 'request': {
+            const request = msg;
+            switch (request.command) {
+                case 'setBreakpoints':
+                    fixSourcePath(true, request.arguments.source);
+                    break;
+                case 'breakpointLocations':
+                    fixSourcePath(true, request.arguments.source);
+                    break;
+                case 'source':
+                    fixSourcePath(true, request.arguments.source);
+                    break;
+                case 'gotoTargets':
+                    fixSourcePath(true, request.arguments.source);
+                    break;
+                case 'launchVSCode':
+                    request.arguments.args.forEach((arg) => fixSourcePath(false, arg));
+                    break;
+            }
+            break;
+        }
+        case 'response': {
+            const response = msg;
+            if (response.success && response.body) {
+                switch (response.command) {
+                    case 'stackTrace':
+                        response.body.stackFrames.forEach(frame => fixSourcePath(false, frame.source));
+                        break;
+                    case 'loadedSources':
+                        response.body.sources.forEach(source => fixSourcePath(false, source));
+                        break;
+                    case 'scopes':
+                        response.body.scopes.forEach(scope => fixSourcePath(false, scope.source));
+                        break;
+                    case 'setFunctionBreakpoints':
+                        response.body.breakpoints.forEach(bp => fixSourcePath(false, bp.source));
+                        break;
+                    case 'setBreakpoints':
+                        response.body.breakpoints.forEach(bp => fixSourcePath(false, bp.source));
+                        break;
+                    case 'disassemble':
+                        {
+                            const di = response;
+                            di.body?.instructions.forEach(di => fixSourcePath(false, di.location));
+                        }
+                        break;
+                }
+            }
+            break;
+        }
+    }
+}
+function getVisibleAndSorted(array) {
+    return array.filter(config => !config.presentation?.hidden).sort((first, second) => {
+        if (!first.presentation) {
+            if (!second.presentation) {
+                return 0;
+            }
+            return 1;
+        }
+        if (!second.presentation) {
+            return -1;
+        }
+        if (!first.presentation.group) {
+            if (!second.presentation.group) {
+                return compareOrders(first.presentation.order, second.presentation.order);
+            }
+            return 1;
+        }
+        if (!second.presentation.group) {
+            return -1;
+        }
+        if (first.presentation.group !== second.presentation.group) {
+            return first.presentation.group.localeCompare(second.presentation.group);
+        }
+        return compareOrders(first.presentation.order, second.presentation.order);
+    });
+}
+function compareOrders(first, second) {
+    if (typeof first !== 'number') {
+        if (typeof second !== 'number') {
+            return 0;
+        }
+        return 1;
+    }
+    if (typeof second !== 'number') {
+        return -1;
+    }
+    return first - second;
+}
+async function saveAllBeforeDebugStart(configurationService, editorService) {
+    const saveBeforeStartConfig = configurationService.getValue('debug.saveBeforeStart', { overrideIdentifier: editorService.activeTextEditorLanguageId });
+    if (saveBeforeStartConfig !== 'none') {
+        await editorService.saveAll();
+        if (saveBeforeStartConfig === 'allEditorsInActiveGroup') {
+            const activeEditor = editorService.activeEditorPane;
+            if (activeEditor && activeEditor.input.resource?.scheme === Schemas.untitled) {
+                await editorService.save({ editor: activeEditor.input, groupId: activeEditor.group.id });
+            }
+        }
+    }
+    await configurationService.reloadConfiguration();
+}
+export { convertToDAPaths, convertToVSCPaths, filterExceptionsFromTelemetry, formatPII, getEvaluatableExpressionAtPosition, getExactExpressionStartAndEnd, getExtensionHostDebugSession, getVisibleAndSorted, isDebuggerMainContribution, isSessionAttach, isUri, saveAllBeforeDebugStart };

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

@@ -0,0 +1,107 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { CONTEXT_EXPRESSION_SELECTED, CONTEXT_LOADED_SCRIPTS_SUPPORTED, CONTEXT_STEP_BACK_SUPPORTED, CONTEXT_FOCUSED_SESSION_IS_ATTACH, CONTEXT_RESTART_FRAME_SUPPORTED, CONTEXT_STEP_INTO_TARGETS_SUPPORTED, CONTEXT_JUMP_TO_CURSOR_SUPPORTED, CONTEXT_SET_VARIABLE_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._onDidFocusStackFrame = ( new Emitter());
+        this._onDidSelectExpression = ( new Emitter());
+        this._onDidEvaluateLazyExpression = ( new Emitter());
+        this._onWillUpdateViews = ( new Emitter());
+        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.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.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;
+        this._focusedStackFrame = stackFrame;
+        this._focusedThread = thread;
+        this._focusedSession = session;
+        this.contextKeyService.bufferChangeEvents(() => {
+            this.loadedScriptsSupportedContextKey.set(session ? !!session.capabilities.supportsLoadedSourcesRequest : false);
+            this.stepBackSupportedContextKey.set(session ? !!session.capabilities.supportsStepBack : false);
+            this.restartFrameSupportedContextKey.set(session ? !!session.capabilities.supportsRestartFrame : false);
+            this.stepIntoTargetsSupported.set(session ? !!session.capabilities.supportsStepInTargetsRequest : false);
+            this.jumpToCursorSupported.set(session ? !!session.capabilities.supportsGotoTargetsRequest : false);
+            this.setVariableSupported.set(session ? !!session.capabilities.supportsSetVariable : false);
+            this.setExpressionSupported.set(session ? !!session.capabilities.supportsSetExpression : false);
+            this.terminateDebuggeeSupported.set(session ? !!session.capabilities.supportTerminateDebuggee : false);
+            this.suspendDebuggeeSupported.set(session ? !!session.capabilities.supportSuspendDebuggee : false);
+            this.disassembleRequestSupported.set(!!session?.capabilities.supportsDisassembleRequest);
+            this.focusedStackFrameHasInstructionPointerReference.set(!!stackFrame?.instructionPointerReference);
+            const attach = !!session && isSessionAttach(session);
+            this.focusedSessionIsAttach.set(attach);
+        });
+        if (shouldEmitForSession) {
+            this._onDidFocusSession.fire(session);
+        }
+        if (shouldEmitForStackFrame) {
+            this._onDidFocusStackFrame.fire({ stackFrame, explicit });
+        }
+    }
+    get onDidFocusSession() {
+        return this._onDidFocusSession.event;
+    }
+    get onDidFocusStackFrame() {
+        return this._onDidFocusStackFrame.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);
+    }
+    async evaluateLazyExpression(expression) {
+        await expression.evaluateLazy();
+        this._onDidEvaluateLazyExpression.fire(expression);
+    }
+}
+export { ViewModel };

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

@@ -0,0 +1,254 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { isObject } from 'monaco-editor/esm/vs/base/common/types.js';
+import { debuggerDisabledMessage, IDebugService } from './debug.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IConfigurationResolverService } from '../../../services/configurationResolver/common/configurationResolver.js';
+import { applyDeprecatedVariableMessage } from '../../../services/configurationResolver/common/configurationResolverUtils.js';
+import { ITextResourcePropertiesService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { Schemas } from 'monaco-editor/esm/vs/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 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.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;
+    }
+    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(nls.localize('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 enabled() {
+        return !this.debuggerWhen || this.contextKeyService.contextMatchesRules(this.debuggerWhen);
+    }
+    get strings() {
+        return this.debuggerContribution.strings ?? this.debuggerContribution.uiMessages;
+    }
+    interestedInLanguage(languageId) {
+        return !!(this.languages && this.languages.indexOf(languageId) >= 0);
+    }
+    hasInitialConfiguration() {
+        return !!this.debuggerContribution.initialConfigurations;
+    }
+    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 = ( nls.localize(
+            'launch.config.comment1',
+            "Use IntelliSense to learn about possible attributes."
+        ));
+        const comment2 = ( nls.localize(
+            'launch.config.comment2',
+            "Hover to view descriptions of existing attributes."
+        ));
+        const comment3 = ( nls.localize(
+            '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 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: ( nls.localize('debugType', "Type of configuration.")),
+                pattern: '^(?!node2)',
+                deprecationMessage: this.debuggerContribution.deprecated || (this.enabled ? undefined : debuggerDisabledMessage(this.type)),
+                doNotSuggest: !!this.debuggerContribution.deprecated,
+                errorMessage: ( nls.localize(
+                    'debugTypeNotRecognised',
+                    "The debug type is not recognized. Make sure that you have a corresponding debug extension installed and that it is enabled."
+                )),
+                patternErrorMessage: ( nls.localize(
+                    'node2NotSupported',
+                    "\"node2\" is no longer supported, use \"node\" instead and set the \"protocol\" attribute to \"inspector\"."
+                ))
+            };
+            properties['request'] = {
+                enum: [request],
+                description: ( nls.localize(
+                    '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 };
+            const attributesCopy = { ...attributes };
+            attributesCopy.properties = {
+                ...properties,
+                ...{
+                    windows: {
+                        $ref: `#/definitions/${definitionId}`,
+                        description: ( nls.localize(
+                            'debugWindowsConfiguration',
+                            "Windows specific launch configuration attributes."
+                        )),
+                        required: [],
+                    },
+                    osx: {
+                        $ref: `#/definitions/${definitionId}`,
+                        description: ( nls.localize('debugOSXConfiguration', "OS X specific launch configuration attributes.")),
+                        required: [],
+                    },
+                    linux: {
+                        $ref: `#/definitions/${definitionId}`,
+                        description: ( nls.localize(
+                            'debugLinuxConfiguration',
+                            "Linux specific launch configuration attributes."
+                        )),
+                        required: [],
+                    }
+                }
+            };
+            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 };

package/dist/vscode/vs/workbench/contrib/debug/common/disassemblyViewInput.js

@@ -0,0 +1,25 @@
+import { EditorInput } from '../../../common/editor/editorInput.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+class DisassemblyViewInput extends EditorInput {
+    constructor() {
+        super(...arguments);
+        this.resource = undefined;
+    }
+    get typeId() {
+        return DisassemblyViewInput.ID;
+    }
+    static get instance() {
+        if (!DisassemblyViewInput._instance || DisassemblyViewInput._instance.isDisposed()) {
+            DisassemblyViewInput._instance = ( new DisassemblyViewInput());
+        }
+        return DisassemblyViewInput._instance;
+    }
+    getName() {
+        return ( localize('disassemblyInputName', "Disassembly"));
+    }
+    matches(other) {
+        return other instanceof DisassemblyViewInput;
+    }
+}
+DisassemblyViewInput.ID = 'debug.disassemblyView.input';
+export { DisassemblyViewInput };