@codingame/monaco-vscode-api 1.82.4 → 1.82.5-next.1

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

@@ -1,344 +0,0 @@
-import { ExtensionsRegistry } from '../../../services/extensions/common/extensionsRegistry.js';
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { launchSchemaId } from '../../../services/configuration/common/configuration.js';
-import { inputsSchema } from '../../../services/configurationResolver/common/configurationResolverSchema.js';
-const debuggersExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'debuggers',
-    defaultExtensionKind: ['workspace'],
-    jsonSchema: {
-        description: ( nls.localize('vscode.extension.contributes.debuggers', 'Contributes debug adapters.')),
-        type: 'array',
-        defaultSnippets: [{ body: [{ type: '' }] }],
-        items: {
-            additionalProperties: false,
-            type: 'object',
-            defaultSnippets: [{ body: { type: '', program: '', runtime: '' } }],
-            properties: {
-                type: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.type',
-                        "Unique identifier for this debug adapter."
-                    )),
-                    type: 'string'
-                },
-                label: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.label',
-                        "Display name for this debug adapter."
-                    )),
-                    type: 'string'
-                },
-                program: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.program',
-                        "Path to the debug adapter program. Path is either absolute or relative to the extension folder."
-                    )),
-                    type: 'string'
-                },
-                args: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.args',
-                        "Optional arguments to pass to the adapter."
-                    )),
-                    type: 'array'
-                },
-                runtime: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.runtime',
-                        "Optional runtime in case the program attribute is not an executable but requires a runtime."
-                    )),
-                    type: 'string'
-                },
-                runtimeArgs: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.runtimeArgs',
-                        "Optional runtime arguments."
-                    )),
-                    type: 'array'
-                },
-                variables: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.variables',
-                        "Mapping from interactive variables (e.g. ${action.pickProcess}) in `launch.json` to a command."
-                    )),
-                    type: 'object'
-                },
-                initialConfigurations: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.initialConfigurations',
-                        "Configurations for generating the initial \'launch.json\'."
-                    )),
-                    type: ['array', 'string'],
-                },
-                languages: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.languages',
-                        "List of languages for which the debug extension could be considered the \"default debugger\"."
-                    )),
-                    type: 'array'
-                },
-                configurationSnippets: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.configurationSnippets',
-                        "Snippets for adding new configurations in \'launch.json\'."
-                    )),
-                    type: 'array'
-                },
-                configurationAttributes: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.configurationAttributes',
-                        "JSON schema configurations for validating \'launch.json\'."
-                    )),
-                    type: 'object'
-                },
-                when: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.when',
-                        "Condition which must be true to enable this type of debugger. Consider using 'shellExecutionSupported', 'virtualWorkspace', 'resourceScheme' or an extension-defined context key as appropriate for this."
-                    )),
-                    type: 'string',
-                    default: ''
-                },
-                deprecated: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.deprecated',
-                        "Optional message to mark this debug type as being deprecated."
-                    )),
-                    type: 'string',
-                    default: ''
-                },
-                windows: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.windows',
-                        "Windows specific settings."
-                    )),
-                    type: 'object',
-                    properties: {
-                        runtime: {
-                            description: ( nls.localize(
-                                'vscode.extension.contributes.debuggers.windows.runtime',
-                                "Runtime used for Windows."
-                            )),
-                            type: 'string'
-                        }
-                    }
-                },
-                osx: {
-                    description: ( nls.localize('vscode.extension.contributes.debuggers.osx', "macOS specific settings.")),
-                    type: 'object',
-                    properties: {
-                        runtime: {
-                            description: ( nls.localize(
-                                'vscode.extension.contributes.debuggers.osx.runtime',
-                                "Runtime used for macOS."
-                            )),
-                            type: 'string'
-                        }
-                    }
-                },
-                linux: {
-                    description: ( nls.localize('vscode.extension.contributes.debuggers.linux', "Linux specific settings.")),
-                    type: 'object',
-                    properties: {
-                        runtime: {
-                            description: ( nls.localize(
-                                'vscode.extension.contributes.debuggers.linux.runtime',
-                                "Runtime used for Linux."
-                            )),
-                            type: 'string'
-                        }
-                    }
-                },
-                strings: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.strings',
-                        "UI strings contributed by this debug adapter."
-                    )),
-                    type: 'object',
-                    properties: {
-                        unverifiedBreakpoints: {
-                            description: ( nls.localize(
-                                'vscode.extension.contributes.debuggers.strings.unverifiedBreakpoints',
-                                "When there are unverified breakpoints in a language supported by this debug adapter, this message will appear on the breakpoint hover and in the breakpoints view. Markdown and command links are supported."
-                            )),
-                            type: 'string'
-                        }
-                    }
-                }
-            }
-        }
-    }
-}));
-const breakpointsExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'breakpoints',
-    jsonSchema: {
-        description: ( nls.localize('vscode.extension.contributes.breakpoints', 'Contributes breakpoints.')),
-        type: 'array',
-        defaultSnippets: [{ body: [{ language: '' }] }],
-        items: {
-            type: 'object',
-            additionalProperties: false,
-            defaultSnippets: [{ body: { language: '' } }],
-            properties: {
-                language: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.breakpoints.language',
-                        "Allow breakpoints for this language."
-                    )),
-                    type: 'string'
-                },
-                when: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.breakpoints.when',
-                        "Condition which must be true to enable breakpoints in this language. Consider matching this to the debugger when clause as appropriate."
-                    )),
-                    type: 'string',
-                    default: ''
-                }
-            }
-        }
-    }
-}));
-const presentationSchema = {
-    type: 'object',
-    description: ( nls.localize(
-        'presentation',
-        "Presentation options on how to show this configuration in the debug configuration dropdown and the command palette."
-    )),
-    properties: {
-        hidden: {
-            type: 'boolean',
-            default: false,
-            description: ( nls.localize(
-                'presentation.hidden',
-                "Controls if this configuration should be shown in the configuration dropdown and the command palette."
-            ))
-        },
-        group: {
-            type: 'string',
-            default: '',
-            description: ( nls.localize(
-                'presentation.group',
-                "Group that this configuration belongs to. Used for grouping and sorting in the configuration dropdown and the command palette."
-            ))
-        },
-        order: {
-            type: 'number',
-            default: 1,
-            description: ( nls.localize(
-                'presentation.order',
-                "Order of this configuration within a group. Used for grouping and sorting in the configuration dropdown and the command palette."
-            ))
-        }
-    },
-    default: {
-        hidden: false,
-        group: '',
-        order: 1
-    }
-};
-const defaultCompound = { name: 'Compound', configurations: [] };
-const launchSchema = {
-    id: launchSchemaId,
-    type: 'object',
-    title: ( nls.localize('app.launch.json.title', "Launch")),
-    allowTrailingCommas: true,
-    allowComments: true,
-    required: [],
-    default: { version: '0.2.0', configurations: [], compounds: [] },
-    properties: {
-        version: {
-            type: 'string',
-            description: ( nls.localize('app.launch.json.version', "Version of this file format.")),
-            default: '0.2.0'
-        },
-        configurations: {
-            type: 'array',
-            description: ( nls.localize(
-                'app.launch.json.configurations',
-                "List of configurations. Add new configurations or edit existing ones by using IntelliSense."
-            )),
-            items: {
-                defaultSnippets: [],
-                'type': 'object',
-                oneOf: []
-            }
-        },
-        compounds: {
-            type: 'array',
-            description: ( nls.localize(
-                'app.launch.json.compounds',
-                "List of compounds. Each compound references multiple configurations which will get launched together."
-            )),
-            items: {
-                type: 'object',
-                required: ['name', 'configurations'],
-                properties: {
-                    name: {
-                        type: 'string',
-                        description: ( nls.localize(
-                            'app.launch.json.compound.name',
-                            "Name of compound. Appears in the launch configuration drop down menu."
-                        ))
-                    },
-                    presentation: presentationSchema,
-                    configurations: {
-                        type: 'array',
-                        default: [],
-                        items: {
-                            oneOf: [{
-                                    enum: [],
-                                    description: ( nls.localize('useUniqueNames', "Please use unique configuration names."))
-                                }, {
-                                    type: 'object',
-                                    required: ['name'],
-                                    properties: {
-                                        name: {
-                                            enum: [],
-                                            description: ( nls.localize(
-                                                'app.launch.json.compound.name',
-                                                "Name of compound. Appears in the launch configuration drop down menu."
-                                            ))
-                                        },
-                                        folder: {
-                                            enum: [],
-                                            description: ( nls.localize(
-                                                'app.launch.json.compound.folder',
-                                                "Name of folder in which the compound is located."
-                                            ))
-                                        }
-                                    }
-                                }]
-                        },
-                        description: ( nls.localize(
-                            'app.launch.json.compounds.configurations',
-                            "Names of configurations that will be started as part of this compound."
-                        ))
-                    },
-                    stopAll: {
-                        type: 'boolean',
-                        default: false,
-                        description: ( nls.localize(
-                            'app.launch.json.compound.stopAll',
-                            "Controls whether manually terminating one session will stop all of the compound sessions."
-                        ))
-                    },
-                    preLaunchTask: {
-                        type: 'string',
-                        default: '',
-                        description: ( nls.localize(
-                            'compoundPrelaunchTask',
-                            "Task to run before any of the compound configurations start."
-                        ))
-                    }
-                },
-                default: defaultCompound
-            },
-            default: [
-                defaultCompound
-            ]
-        },
-        inputs: inputsSchema.definitions.inputs
-    }
-};
-export { breakpointsExtPoint, debuggersExtPoint, launchSchema, presentationSchema };

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

@@ -1,121 +0,0 @@
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { normalize, isAbsolute } from 'monaco-editor/esm/vs/base/common/path.js';
-import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
-import { DEBUG_SCHEME } from './debug.js';
-import { SIDE_GROUP, ACTIVE_GROUP } from '../../../services/editor/common/editorService.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { isUri } from './debugUtils.js';
-const UNKNOWN_SOURCE_LABEL = ( nls.localize('unknownSource', "Unknown Source"));
-class Source {
-    constructor(raw_, sessionId, uriIdentityService, logService) {
-        let path;
-        if (raw_) {
-            this.raw = raw_;
-            path = this.raw.path || this.raw.name || '';
-            this.available = true;
-        }
-        else {
-            this.raw = { name: UNKNOWN_SOURCE_LABEL };
-            this.available = false;
-            path = `${DEBUG_SCHEME}:${UNKNOWN_SOURCE_LABEL}`;
-        }
-        this.uri = getUriFromSource(this.raw, path, sessionId, uriIdentityService, logService);
-    }
-    get name() {
-        return this.raw.name || resources.basenameOrAuthority(this.uri);
-    }
-    get origin() {
-        return this.raw.origin;
-    }
-    get presentationHint() {
-        return this.raw.presentationHint;
-    }
-    get reference() {
-        return this.raw.sourceReference;
-    }
-    get inMemory() {
-        return this.uri.scheme === DEBUG_SCHEME;
-    }
-    openInEditor(editorService, selection, preserveFocus, sideBySide, pinned) {
-        return !this.available ? Promise.resolve(undefined) : editorService.openEditor({
-            resource: this.uri,
-            description: this.origin,
-            options: {
-                preserveFocus,
-                selection,
-                revealIfOpened: true,
-                selectionRevealType: 1 ,
-                pinned
-            }
-        }, sideBySide ? SIDE_GROUP : ACTIVE_GROUP);
-    }
-    static getEncodedDebugData(modelUri) {
-        let path;
-        let sourceReference;
-        let sessionId;
-        switch (modelUri.scheme) {
-            case Schemas.file:
-                path = normalize(modelUri.fsPath);
-                break;
-            case DEBUG_SCHEME:
-                path = modelUri.path;
-                if (modelUri.query) {
-                    const keyvalues = modelUri.query.split('&');
-                    for (const keyvalue of keyvalues) {
-                        const pair = keyvalue.split('=');
-                        if (pair.length === 2) {
-                            switch (pair[0]) {
-                                case 'session':
-                                    sessionId = pair[1];
-                                    break;
-                                case 'ref':
-                                    sourceReference = parseInt(pair[1]);
-                                    break;
-                            }
-                        }
-                    }
-                }
-                break;
-            default:
-                path = ( modelUri.toString());
-                break;
-        }
-        return {
-            name: resources.basenameOrAuthority(modelUri),
-            path,
-            sourceReference,
-            sessionId
-        };
-    }
-}
-function getUriFromSource(raw, path, sessionId, uriIdentityService, logService) {
-    const _getUriFromSource = (path) => {
-        if (typeof raw.sourceReference === 'number' && raw.sourceReference > 0) {
-            return ( URI.from({
-                scheme: DEBUG_SCHEME,
-                path,
-                query: `session=${sessionId}&ref=${raw.sourceReference}`
-            }));
-        }
-        if (path && isUri(path)) {
-            return uriIdentityService.asCanonicalUri(( URI.parse(path)));
-        }
-        if (path && isAbsolute(path)) {
-            return uriIdentityService.asCanonicalUri(URI.file(path));
-        }
-        return uriIdentityService.asCanonicalUri(( URI.from({
-            scheme: DEBUG_SCHEME,
-            path,
-            query: `session=${sessionId}`
-        })));
-    };
-    try {
-        return _getUriFromSource(path);
-    }
-    catch (err) {
-        logService.error('Invalid path from debug adapter: ' + path);
-        return _getUriFromSource('/invalidDebugSource');
-    }
-}
-export { Source, UNKNOWN_SOURCE_LABEL, getUriFromSource };

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

@@ -1,173 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { Breakpoint, FunctionBreakpoint, ExceptionBreakpoint, DataBreakpoint, Expression } from './debugModel.js';
-import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
-import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { observableValue } from 'monaco-editor/esm/vs/base/common/observable.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.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('debugBreakpoints', this.loadBreakpoints());
-        this.functionBreakpoints = observableValue('debugFunctionBreakpoints', this.loadFunctionBreakpoints());
-        this.exceptionBreakpoints = observableValue('debugExceptionBreakpoints', this.loadExceptionBreakpoints());
-        this.dataBreakpoints = observableValue('debugDataBreakpoints', this.loadDataBreakpoints());
-        this.watchExpressions = observableValue('debugWatchExpressions', 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) => {
-                return ( new Breakpoint(( URI.parse(breakpoint.uri.external || breakpoint.source.uri.external)), breakpoint.lineNumber, breakpoint.column, breakpoint.enabled, breakpoint.condition, breakpoint.hitCondition, breakpoint.logMessage, breakpoint.adapterData, 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.name, fb.enabled, fb.hitCondition, fb.condition, fb.logMessage, 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.filter,
-                    exBreakpoint.label,
-                    exBreakpoint.enabled,
-                    exBreakpoint.supportsCondition,
-                    exBreakpoint.condition,
-                    exBreakpoint.description,
-                    exBreakpoint.conditionDescription,
-                    !!exBreakpoint.fallback
-                ));
-            }));
-        }
-        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.description,
-                    dbp.dataId,
-                    true,
-                    dbp.enabled,
-                    dbp.hitCondition,
-                    dbp.condition,
-                    dbp.logMessage,
-                    dbp.accessTypes,
-                    dbp.accessType,
-                    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 'monaco-editor/esm/vs/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 };