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

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

@@ -1,1480 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { distinct, findLastIndex } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { RunOnceScheduler, DeferredPromise } from 'monaco-editor/esm/vs/base/common/async.js';
-import { decodeBase64, VSBuffer, encodeBase64 } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
-import { stringHash } from 'monaco-editor/esm/vs/base/common/hash.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { mixin } from 'monaco-editor/esm/vs/base/common/objects.js';
-import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
-import { isString, isUndefinedOrNull } from 'monaco-editor/esm/vs/base/common/types.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
-import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
-import { DEBUG_MEMORY_SCHEME } from './debug.js';
-import { getUriFromSource, UNKNOWN_SOURCE_LABEL } from './debugSource.js';
-import { DisassemblyViewInput } from './disassemblyViewInput.js';
-import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { autorun } from 'monaco-editor/esm/vs/base/common/observable.js';
-class ExpressionContainer {
-    static { this.allValues = ( (new Map())); }
-    static { this.BASE_CHUNK_SIZE = 100; }
-    constructor(session, threadId, _reference, id, namedVariables = 0, indexedVariables = 0, memoryReference = undefined, startOfVariables = 0, presentationHint = undefined) {
-        this.session = session;
-        this.threadId = threadId;
-        this._reference = _reference;
-        this.id = id;
-        this.namedVariables = namedVariables;
-        this.indexedVariables = indexedVariables;
-        this.memoryReference = memoryReference;
-        this.startOfVariables = startOfVariables;
-        this.presentationHint = presentationHint;
-        this.valueChanged = false;
-        this._value = '';
-    }
-    get reference() {
-        return this._reference;
-    }
-    set reference(value) {
-        this._reference = value;
-        this.children = undefined;
-    }
-    async evaluateLazy() {
-        if (typeof this.reference === 'undefined') {
-            return;
-        }
-        const response = await this.session.variables(this.reference, this.threadId, undefined, undefined, undefined);
-        if (!response || !response.body || !response.body.variables || response.body.variables.length !== 1) {
-            return;
-        }
-        const dummyVar = response.body.variables[0];
-        this.reference = dummyVar.variablesReference;
-        this._value = dummyVar.value;
-        this.namedVariables = dummyVar.namedVariables;
-        this.indexedVariables = dummyVar.indexedVariables;
-        this.memoryReference = dummyVar.memoryReference;
-        this.presentationHint = dummyVar.presentationHint;
-        this.adoptLazyResponse(dummyVar);
-    }
-    adoptLazyResponse(response) {
-    }
-    getChildren() {
-        if (!this.children) {
-            this.children = this.doGetChildren();
-        }
-        return this.children;
-    }
-    async doGetChildren() {
-        if (!this.hasChildren) {
-            return [];
-        }
-        if (!this.getChildrenInChunks) {
-            return this.fetchVariables(undefined, undefined, undefined);
-        }
-        const children = this.namedVariables ? await this.fetchVariables(undefined, undefined, 'named') : [];
-        let chunkSize = ExpressionContainer.BASE_CHUNK_SIZE;
-        while (!!this.indexedVariables && this.indexedVariables > chunkSize * ExpressionContainer.BASE_CHUNK_SIZE) {
-            chunkSize *= ExpressionContainer.BASE_CHUNK_SIZE;
-        }
-        if (!!this.indexedVariables && this.indexedVariables > chunkSize) {
-            const numberOfChunks = Math.ceil(this.indexedVariables / chunkSize);
-            for (let i = 0; i < numberOfChunks; i++) {
-                const start = (this.startOfVariables || 0) + i * chunkSize;
-                const count = Math.min(chunkSize, this.indexedVariables - i * chunkSize);
-                children.push(( (new Variable(
-                    this.session,
-                    this.threadId,
-                    this,
-                    this.reference,
-                    `[${start}..${start + count - 1}]`,
-                    '',
-                    '',
-                    undefined,
-                    count,
-                    undefined,
-                    { kind: 'virtual' },
-                    undefined,
-                    undefined,
-                    true,
-                    start
-                ))));
-            }
-            return children;
-        }
-        const variables = await this.fetchVariables(this.startOfVariables, this.indexedVariables, 'indexed');
-        return children.concat(variables);
-    }
-    getId() {
-        return this.id;
-    }
-    getSession() {
-        return this.session;
-    }
-    get value() {
-        return this._value;
-    }
-    get hasChildren() {
-        return !!this.reference && this.reference > 0 && !this.presentationHint?.lazy;
-    }
-    async fetchVariables(start, count, filter) {
-        try {
-            const response = await this.session.variables(this.reference || 0, this.threadId, filter, start, count);
-            if (!response || !response.body || !response.body.variables) {
-                return [];
-            }
-            const nameCount = ( (new Map()));
-            const vars = ( (response.body.variables.filter(v => !!v).map((v) => {
-                if (isString(v.value) && isString(v.name) && typeof v.variablesReference === 'number') {
-                    const count = nameCount.get(v.name) || 0;
-                    const idDuplicationIndex = count > 0 ? ( (count.toString())) : '';
-                    nameCount.set(v.name, count + 1);
-                    return (
-                         (new Variable(
-                            this.session,
-                            this.threadId,
-                            this,
-                            v.variablesReference,
-                            v.name,
-                            v.evaluateName,
-                            v.value,
-                            v.namedVariables,
-                            v.indexedVariables,
-                            v.memoryReference,
-                            v.presentationHint,
-                            v.type,
-                            v.__vscodeVariableMenuContext,
-                            true,
-                            0,
-                            idDuplicationIndex
-                        ))
-                    );
-                }
-                return (
-                     (new Variable(
-                        this.session,
-                        this.threadId,
-                        this,
-                        0,
-                        '',
-                        undefined,
-                         (nls.localize('invalidVariableAttributes', "Invalid variable attributes")),
-                        0,
-                        0,
-                        undefined,
-                        { kind: 'virtual' },
-                        undefined,
-                        undefined,
-                        false
-                    ))
-                );
-            })));
-            if (this.session.autoExpandLazyVariables) {
-                await Promise.all(( (vars.map(v => v.presentationHint?.lazy && v.evaluateLazy()))));
-            }
-            return vars;
-        }
-        catch (e) {
-            return [( (new Variable(
-                this.session,
-                this.threadId,
-                this,
-                0,
-                '',
-                undefined,
-                e.message,
-                0,
-                0,
-                undefined,
-                { kind: 'virtual' },
-                undefined,
-                undefined,
-                false
-            )))];
-        }
-    }
-    get getChildrenInChunks() {
-        return !!this.indexedVariables;
-    }
-    set value(value) {
-        this._value = value;
-        this.valueChanged = !!ExpressionContainer.allValues.get(this.getId()) &&
-            ExpressionContainer.allValues.get(this.getId()) !== Expression.DEFAULT_VALUE && ExpressionContainer.allValues.get(this.getId()) !== value;
-        ExpressionContainer.allValues.set(this.getId(), value);
-    }
-    toString() {
-        return this.value;
-    }
-    async evaluateExpression(expression, session, stackFrame, context, keepLazyVars = false) {
-        if (!session || (!stackFrame && context !== 'repl')) {
-            this.value = context === 'repl' ? ( (nls.localize('startDebugFirst', "Please start a debug session to evaluate expressions"))) : Expression.DEFAULT_VALUE;
-            this.reference = 0;
-            return false;
-        }
-        this.session = session;
-        try {
-            const response = await session.evaluate(expression, stackFrame ? stackFrame.frameId : undefined, context);
-            if (response && response.body) {
-                this.value = response.body.result || '';
-                this.reference = response.body.variablesReference;
-                this.namedVariables = response.body.namedVariables;
-                this.indexedVariables = response.body.indexedVariables;
-                this.memoryReference = response.body.memoryReference;
-                this.type = response.body.type || this.type;
-                this.presentationHint = response.body.presentationHint;
-                if (!keepLazyVars && response.body.presentationHint?.lazy) {
-                    await this.evaluateLazy();
-                }
-                return true;
-            }
-            return false;
-        }
-        catch (e) {
-            this.value = e.message || '';
-            this.reference = 0;
-            return false;
-        }
-    }
-}
-function handleSetResponse(expression, response) {
-    if (response && response.body) {
-        expression.value = response.body.value || '';
-        expression.type = response.body.type || expression.type;
-        expression.reference = response.body.variablesReference;
-        expression.namedVariables = response.body.namedVariables;
-        expression.indexedVariables = response.body.indexedVariables;
-    }
-}
-class Expression extends ExpressionContainer {
-    static { this.DEFAULT_VALUE = ( (nls.localize('notAvailable', "not available"))); }
-    constructor(name, id = generateUuid()) {
-        super(undefined, undefined, 0, id);
-        this.name = name;
-        this.available = false;
-        if (name) {
-            this.value = Expression.DEFAULT_VALUE;
-        }
-    }
-    async evaluate(session, stackFrame, context, keepLazyVars) {
-        this.available = await this.evaluateExpression(this.name, session, stackFrame, context, keepLazyVars);
-    }
-    toString() {
-        return `${this.name}\n${this.value}`;
-    }
-    async setExpression(value, stackFrame) {
-        if (!this.session) {
-            return;
-        }
-        const response = await this.session.setExpression(stackFrame.frameId, this.name, value);
-        handleSetResponse(this, response);
-    }
-}
-class Variable extends ExpressionContainer {
-    constructor(session, threadId, parent, reference, name, evaluateName, value, namedVariables, indexedVariables, memoryReference, presentationHint, type = undefined, variableMenuContext = undefined, available = true, startOfVariables = 0, idDuplicationIndex = '') {
-        super(session, threadId, reference, `variable:${parent.getId()}:${name}:${idDuplicationIndex}`, namedVariables, indexedVariables, memoryReference, startOfVariables, presentationHint);
-        this.parent = parent;
-        this.name = name;
-        this.evaluateName = evaluateName;
-        this.variableMenuContext = variableMenuContext;
-        this.available = available;
-        this.value = value || '';
-        this.type = type;
-    }
-    async setVariable(value, stackFrame) {
-        if (!this.session) {
-            return;
-        }
-        try {
-            if (this.session.capabilities.supportsSetExpression && !this.session.capabilities.supportsSetVariable && this.evaluateName) {
-                return this.setExpression(value, stackFrame);
-            }
-            const response = await this.session.setVariable(this.parent.reference, this.name, value);
-            handleSetResponse(this, response);
-        }
-        catch (err) {
-            this.errorMessage = err.message;
-        }
-    }
-    async setExpression(value, stackFrame) {
-        if (!this.session || !this.evaluateName) {
-            return;
-        }
-        const response = await this.session.setExpression(stackFrame.frameId, this.evaluateName, value);
-        handleSetResponse(this, response);
-    }
-    toString() {
-        return this.name ? `${this.name}: ${this.value}` : this.value;
-    }
-    adoptLazyResponse(response) {
-        this.evaluateName = response.evaluateName;
-    }
-    toDebugProtocolObject() {
-        return {
-            name: this.name,
-            variablesReference: this.reference || 0,
-            memoryReference: this.memoryReference,
-            value: this.value,
-            evaluateName: this.evaluateName
-        };
-    }
-}
-class Scope extends ExpressionContainer {
-    constructor(stackFrame, id, name, reference, expensive, namedVariables, indexedVariables, range) {
-        super(stackFrame.thread.session, stackFrame.thread.threadId, reference, `scope:${name}:${id}`, namedVariables, indexedVariables);
-        this.name = name;
-        this.expensive = expensive;
-        this.range = range;
-    }
-    toString() {
-        return this.name;
-    }
-    toDebugProtocolObject() {
-        return {
-            name: this.name,
-            variablesReference: this.reference || 0,
-            expensive: this.expensive
-        };
-    }
-}
-class ErrorScope extends Scope {
-    constructor(stackFrame, index, message) {
-        super(stackFrame, index, message, 0, false);
-    }
-    toString() {
-        return this.name;
-    }
-}
-class StackFrame {
-    constructor(thread, frameId, source, name, presentationHint, range, index, canRestart, instructionPointerReference) {
-        this.thread = thread;
-        this.frameId = frameId;
-        this.source = source;
-        this.name = name;
-        this.presentationHint = presentationHint;
-        this.range = range;
-        this.index = index;
-        this.canRestart = canRestart;
-        this.instructionPointerReference = instructionPointerReference;
-    }
-    getId() {
-        return `stackframe:${this.thread.getId()}:${this.index}:${this.source.name}`;
-    }
-    getScopes() {
-        if (!this.scopes) {
-            this.scopes = this.thread.session.scopes(this.frameId, this.thread.threadId).then(response => {
-                if (!response || !response.body || !response.body.scopes) {
-                    return [];
-                }
-                const usedIds = ( (new Set()));
-                return (
-                     (response.body.scopes.map(rs => {
-                        let id = 0;
-                        do {
-                            id = stringHash(`${rs.name}:${rs.line}:${rs.column}`, id);
-                        } while (( (usedIds.has(id))));
-                        usedIds.add(id);
-                        return (
-                             (new Scope(
-                                this,
-                                id,
-                                rs.name,
-                                rs.variablesReference,
-                                rs.expensive,
-                                rs.namedVariables,
-                                rs.indexedVariables,
-                                rs.line && rs.column && rs.endLine && rs.endColumn ? ( (new Range(rs.line, rs.column, rs.endLine, rs.endColumn))) : undefined
-                            ))
-                        );
-                    }))
-                );
-            }, err => [( (new ErrorScope(this, 0, err.message)))]);
-        }
-        return this.scopes;
-    }
-    async getMostSpecificScopes(range) {
-        const scopes = await this.getScopes();
-        const nonExpensiveScopes = scopes.filter(s => !s.expensive);
-        const haveRangeInfo = ( (nonExpensiveScopes.some(s => !!s.range)));
-        if (!haveRangeInfo) {
-            return nonExpensiveScopes;
-        }
-        const scopesContainingRange = nonExpensiveScopes.filter(scope => scope.range && Range.containsRange(scope.range, range))
-            .sort((first, second) => (first.range.endLineNumber - first.range.startLineNumber) - (second.range.endLineNumber - second.range.startLineNumber));
-        return scopesContainingRange.length ? scopesContainingRange : nonExpensiveScopes;
-    }
-    restart() {
-        return this.thread.session.restartFrame(this.frameId, this.thread.threadId);
-    }
-    forgetScopes() {
-        this.scopes = undefined;
-    }
-    toString() {
-        const lineNumberToString = typeof this.range.startLineNumber === 'number' ? `:${this.range.startLineNumber}` : '';
-        const sourceToString = `${this.source.inMemory ? this.source.name : this.source.uri.fsPath}${lineNumberToString}`;
-        return sourceToString === UNKNOWN_SOURCE_LABEL ? this.name : `${this.name} (${sourceToString})`;
-    }
-    async openInEditor(editorService, preserveFocus, sideBySide, pinned) {
-        const threadStopReason = this.thread.stoppedDetails?.reason;
-        if (this.instructionPointerReference &&
-            (threadStopReason === 'instruction breakpoint' ||
-                (threadStopReason === 'step' && this.thread.lastSteppingGranularity === 'instruction'))) {
-            return editorService.openEditor(DisassemblyViewInput.instance, { pinned: true });
-        }
-        if (this.source.available) {
-            return this.source.openInEditor(editorService, this.range, preserveFocus, sideBySide, pinned);
-        }
-        return undefined;
-    }
-    equals(other) {
-        return (this.name === other.name) && (other.thread === this.thread) && (this.frameId === other.frameId) && (other.source === this.source) && (Range.equalsRange(this.range, other.range));
-    }
-}
-class Thread {
-    constructor(session, name, threadId) {
-        this.session = session;
-        this.name = name;
-        this.threadId = threadId;
-        this.callStackCancellationTokens = [];
-        this.reachedEndOfCallStack = false;
-        this.callStack = [];
-        this.staleCallStack = [];
-        this.stopped = false;
-    }
-    getId() {
-        return `thread:${this.session.getId()}:${this.threadId}`;
-    }
-    clearCallStack() {
-        if (this.callStack.length) {
-            this.staleCallStack = this.callStack;
-        }
-        this.callStack = [];
-        this.callStackCancellationTokens.forEach(c => c.dispose(true));
-        this.callStackCancellationTokens = [];
-    }
-    getCallStack() {
-        return this.callStack;
-    }
-    getStaleCallStack() {
-        return this.staleCallStack;
-    }
-    getTopStackFrame() {
-        const callStack = this.getCallStack();
-        const firstAvailableStackFrame = callStack.find(sf => !!(sf &&
-            ((this.stoppedDetails?.reason === 'instruction breakpoint' || (this.stoppedDetails?.reason === 'step' && this.lastSteppingGranularity === 'instruction')) && sf.instructionPointerReference) ||
-            (sf.source && sf.source.available && sf.source.presentationHint !== 'deemphasize')));
-        return firstAvailableStackFrame;
-    }
-    get stateLabel() {
-        if (this.stoppedDetails) {
-            return this.stoppedDetails.description ||
-                (this.stoppedDetails.reason ? ( (nls.localize(
-                { key: 'pausedOn', comment: ['indicates reason for program being paused'] },
-                "Paused on {0}",
-                this.stoppedDetails.reason
-            ))) : ( (nls.localize('paused', "Paused"))));
-        }
-        return (
-             (nls.localize({ key: 'running', comment: ['indicates state'] }, "Running"))
-        );
-    }
-    async fetchCallStack(levels = 20) {
-        if (this.stopped) {
-            const start = this.callStack.length;
-            const callStack = await this.getCallStackImpl(start, levels);
-            this.reachedEndOfCallStack = callStack.length < levels;
-            if (start < this.callStack.length) {
-                this.callStack.splice(start, this.callStack.length - start);
-            }
-            this.callStack = this.callStack.concat(callStack || []);
-            if (typeof this.stoppedDetails?.totalFrames === 'number' && this.stoppedDetails.totalFrames === this.callStack.length) {
-                this.reachedEndOfCallStack = true;
-            }
-        }
-    }
-    async getCallStackImpl(startFrame, levels) {
-        try {
-            const tokenSource = ( (new CancellationTokenSource()));
-            this.callStackCancellationTokens.push(tokenSource);
-            const response = await this.session.stackTrace(this.threadId, startFrame, levels, tokenSource.token);
-            if (!response || !response.body || tokenSource.token.isCancellationRequested) {
-                return [];
-            }
-            if (this.stoppedDetails) {
-                this.stoppedDetails.totalFrames = response.body.totalFrames;
-            }
-            return (
-                 (response.body.stackFrames.map((rsf, index) => {
-                    const source = this.session.getSource(rsf.source);
-                    return (
-                         (new StackFrame(
-                            this,
-                            rsf.id,
-                            source,
-                            rsf.name,
-                            rsf.presentationHint,
-                             (new Range(rsf.line, rsf.column, rsf.endLine || rsf.line, rsf.endColumn || rsf.column)),
-                            startFrame + index,
-                            typeof rsf.canRestart === 'boolean' ? rsf.canRestart : true,
-                            rsf.instructionPointerReference
-                        ))
-                    );
-                }))
-            );
-        }
-        catch (err) {
-            if (this.stoppedDetails) {
-                this.stoppedDetails.framesErrorMessage = err.message;
-            }
-            return [];
-        }
-    }
-    get exceptionInfo() {
-        if (this.stoppedDetails && this.stoppedDetails.reason === 'exception') {
-            if (this.session.capabilities.supportsExceptionInfoRequest) {
-                return this.session.exceptionInfo(this.threadId);
-            }
-            return Promise.resolve({
-                description: this.stoppedDetails.text,
-                breakMode: null
-            });
-        }
-        return Promise.resolve(undefined);
-    }
-    next(granularity) {
-        return this.session.next(this.threadId, granularity);
-    }
-    stepIn(granularity) {
-        return this.session.stepIn(this.threadId, undefined, granularity);
-    }
-    stepOut(granularity) {
-        return this.session.stepOut(this.threadId, granularity);
-    }
-    stepBack(granularity) {
-        return this.session.stepBack(this.threadId, granularity);
-    }
-    continue() {
-        return this.session.continue(this.threadId);
-    }
-    pause() {
-        return this.session.pause(this.threadId);
-    }
-    terminate() {
-        return this.session.terminateThreads([this.threadId]);
-    }
-    reverseContinue() {
-        return this.session.reverseContinue(this.threadId);
-    }
-}
-const getUriForDebugMemory = (sessionId, memoryReference, range, displayName = 'memory') => {
-    return (
-         (URI.from({
-            scheme: DEBUG_MEMORY_SCHEME,
-            authority: sessionId,
-            path: '/' + encodeURIComponent(memoryReference) + `/${encodeURIComponent(displayName)}.bin`,
-            query: range ? `?range=${range.fromOffset}:${range.toOffset}` : undefined,
-        }))
-    );
-};
-class MemoryRegion extends Disposable {
-    constructor(memoryReference, session) {
-        super();
-        this.memoryReference = memoryReference;
-        this.session = session;
-        this.invalidateEmitter = this._register(( (new Emitter())));
-        this.onDidInvalidate = this.invalidateEmitter.event;
-        this.writable = !!this.session.capabilities.supportsWriteMemoryRequest;
-        this._register(session.onDidInvalidateMemory(e => {
-            if (e.body.memoryReference === memoryReference) {
-                this.invalidate(e.body.offset, e.body.count - e.body.offset);
-            }
-        }));
-    }
-    async read(fromOffset, toOffset) {
-        const length = toOffset - fromOffset;
-        const offset = fromOffset;
-        const result = await this.session.readMemory(this.memoryReference, offset, length);
-        if (result === undefined || !result.body?.data) {
-            return [{ type: 1 , offset, length }];
-        }
-        let data;
-        try {
-            data = decodeBase64(result.body.data);
-        }
-        catch {
-            return [{ type: 2 , offset, length, error: 'Invalid base64 data from debug adapter' }];
-        }
-        const unreadable = result.body.unreadableBytes || 0;
-        const dataLength = length - unreadable;
-        if (data.byteLength < dataLength) {
-            const pad = VSBuffer.alloc(dataLength - data.byteLength);
-            pad.buffer.fill(0);
-            data = VSBuffer.concat([data, pad], dataLength);
-        }
-        else if (data.byteLength > dataLength) {
-            data = data.slice(0, dataLength);
-        }
-        if (!unreadable) {
-            return [{ type: 0 , offset, length, data }];
-        }
-        return [
-            { type: 0 , offset, length: dataLength, data },
-            { type: 1 , offset: offset + dataLength, length: unreadable },
-        ];
-    }
-    async write(offset, data) {
-        const result = await this.session.writeMemory(this.memoryReference, offset, encodeBase64(data), true);
-        const written = result?.body?.bytesWritten ?? data.byteLength;
-        this.invalidate(offset, offset + written);
-        return written;
-    }
-    dispose() {
-        super.dispose();
-    }
-    invalidate(fromOffset, toOffset) {
-        this.invalidateEmitter.fire({ fromOffset, toOffset });
-    }
-}
-class Enablement {
-    constructor(enabled, id) {
-        this.enabled = enabled;
-        this.id = id;
-    }
-    getId() {
-        return this.id;
-    }
-}
-function toBreakpointSessionData(data, capabilities) {
-    return mixin({
-        supportsConditionalBreakpoints: !!capabilities.supportsConditionalBreakpoints,
-        supportsHitConditionalBreakpoints: !!capabilities.supportsHitConditionalBreakpoints,
-        supportsLogPoints: !!capabilities.supportsLogPoints,
-        supportsFunctionBreakpoints: !!capabilities.supportsFunctionBreakpoints,
-        supportsDataBreakpoints: !!capabilities.supportsDataBreakpoints,
-        supportsInstructionBreakpoints: !!capabilities.supportsInstructionBreakpoints
-    }, data);
-}
-class BaseBreakpoint extends Enablement {
-    constructor(enabled, hitCondition, condition, logMessage, id) {
-        super(enabled, id);
-        this.hitCondition = hitCondition;
-        this.condition = condition;
-        this.logMessage = logMessage;
-        this.sessionData = ( (new Map()));
-        if (enabled === undefined) {
-            this.enabled = true;
-        }
-    }
-    setSessionData(sessionId, data) {
-        if (!data) {
-            this.sessionData.delete(sessionId);
-        }
-        else {
-            data.sessionId = sessionId;
-            this.sessionData.set(sessionId, data);
-        }
-        const allData = Array.from(( (this.sessionData.values())));
-        const verifiedData = distinct(allData.filter(d => d.verified), d => `${d.line}:${d.column}`);
-        if (verifiedData.length) {
-            this.data = verifiedData.length === 1 ? verifiedData[0] : undefined;
-        }
-        else {
-            this.data = allData.length ? allData[0] : undefined;
-        }
-    }
-    get message() {
-        if (!this.data) {
-            return undefined;
-        }
-        return this.data.message;
-    }
-    get verified() {
-        return this.data ? this.data.verified : true;
-    }
-    get sessionsThatVerified() {
-        const sessionIds = [];
-        for (const [sessionId, data] of this.sessionData) {
-            if (data.verified) {
-                sessionIds.push(sessionId);
-            }
-        }
-        return sessionIds;
-    }
-    getIdFromAdapter(sessionId) {
-        const data = this.sessionData.get(sessionId);
-        return data ? data.id : undefined;
-    }
-    getDebugProtocolBreakpoint(sessionId) {
-        const data = this.sessionData.get(sessionId);
-        if (data) {
-            const bp = {
-                id: data.id,
-                verified: data.verified,
-                message: data.message,
-                source: data.source,
-                line: data.line,
-                column: data.column,
-                endLine: data.endLine,
-                endColumn: data.endColumn,
-                instructionReference: data.instructionReference,
-                offset: data.offset
-            };
-            return bp;
-        }
-        return undefined;
-    }
-    toJSON() {
-        const result = Object.create(null);
-        result.id = this.getId();
-        result.enabled = this.enabled;
-        result.condition = this.condition;
-        result.hitCondition = this.hitCondition;
-        result.logMessage = this.logMessage;
-        return result;
-    }
-}
-class Breakpoint extends BaseBreakpoint {
-    constructor(_uri, _lineNumber, _column, enabled, condition, hitCondition, logMessage, _adapterData, textFileService, uriIdentityService, logService, id = generateUuid()) {
-        super(enabled, hitCondition, condition, logMessage, id);
-        this._uri = _uri;
-        this._lineNumber = _lineNumber;
-        this._column = _column;
-        this._adapterData = _adapterData;
-        this.textFileService = textFileService;
-        this.uriIdentityService = uriIdentityService;
-        this.logService = logService;
-    }
-    get originalUri() {
-        return this._uri;
-    }
-    get lineNumber() {
-        return this.verified && this.data && typeof this.data.line === 'number' ? this.data.line : this._lineNumber;
-    }
-    get verified() {
-        if (this.data) {
-            return this.data.verified && !this.textFileService.isDirty(this._uri);
-        }
-        return true;
-    }
-    get uri() {
-        return this.verified && this.data && this.data.source ? getUriFromSource(this.data.source, this.data.source.path, this.data.sessionId, this.uriIdentityService, this.logService) : this._uri;
-    }
-    get column() {
-        return this.verified && this.data && typeof this.data.column === 'number' ? this.data.column : this._column;
-    }
-    get message() {
-        if (this.textFileService.isDirty(this.uri)) {
-            return (
-                 (nls.localize(
-                    'breakpointDirtydHover',
-                    "Unverified breakpoint. File is modified, please restart debug session."
-                ))
-            );
-        }
-        return super.message;
-    }
-    get adapterData() {
-        return this.data && this.data.source && this.data.source.adapterData ? this.data.source.adapterData : this._adapterData;
-    }
-    get endLineNumber() {
-        return this.verified && this.data ? this.data.endLine : undefined;
-    }
-    get endColumn() {
-        return this.verified && this.data ? this.data.endColumn : undefined;
-    }
-    get sessionAgnosticData() {
-        return {
-            lineNumber: this._lineNumber,
-            column: this._column
-        };
-    }
-    get supported() {
-        if (!this.data) {
-            return true;
-        }
-        if (this.logMessage && !this.data.supportsLogPoints) {
-            return false;
-        }
-        if (this.condition && !this.data.supportsConditionalBreakpoints) {
-            return false;
-        }
-        if (this.hitCondition && !this.data.supportsHitConditionalBreakpoints) {
-            return false;
-        }
-        return true;
-    }
-    setSessionData(sessionId, data) {
-        super.setSessionData(sessionId, data);
-        if (!this._adapterData) {
-            this._adapterData = this.adapterData;
-        }
-    }
-    toJSON() {
-        const result = super.toJSON();
-        result.uri = this._uri;
-        result.lineNumber = this._lineNumber;
-        result.column = this._column;
-        result.adapterData = this.adapterData;
-        return result;
-    }
-    toString() {
-        return `${resources.basenameOrAuthority(this.uri)} ${this.lineNumber}`;
-    }
-    update(data) {
-        if (!isUndefinedOrNull(data.lineNumber)) {
-            this._lineNumber = data.lineNumber;
-        }
-        if (!isUndefinedOrNull(data.column)) {
-            this._column = data.column;
-        }
-        if (!isUndefinedOrNull(data.condition)) {
-            this.condition = data.condition;
-        }
-        if (!isUndefinedOrNull(data.hitCondition)) {
-            this.hitCondition = data.hitCondition;
-        }
-        if (!isUndefinedOrNull(data.logMessage)) {
-            this.logMessage = data.logMessage;
-        }
-    }
-}
-class FunctionBreakpoint extends BaseBreakpoint {
-    constructor(name, enabled, hitCondition, condition, logMessage, id = generateUuid()) {
-        super(enabled, hitCondition, condition, logMessage, id);
-        this.name = name;
-    }
-    toJSON() {
-        const result = super.toJSON();
-        result.name = this.name;
-        return result;
-    }
-    get supported() {
-        if (!this.data) {
-            return true;
-        }
-        return this.data.supportsFunctionBreakpoints;
-    }
-    toString() {
-        return this.name;
-    }
-}
-class DataBreakpoint extends BaseBreakpoint {
-    constructor(description, dataId, canPersist, enabled, hitCondition, condition, logMessage, accessTypes, accessType, id = generateUuid()) {
-        super(enabled, hitCondition, condition, logMessage, id);
-        this.description = description;
-        this.dataId = dataId;
-        this.canPersist = canPersist;
-        this.accessTypes = accessTypes;
-        this.accessType = accessType;
-    }
-    toJSON() {
-        const result = super.toJSON();
-        result.description = this.description;
-        result.dataId = this.dataId;
-        result.accessTypes = this.accessTypes;
-        result.accessType = this.accessType;
-        return result;
-    }
-    get supported() {
-        if (!this.data) {
-            return true;
-        }
-        return this.data.supportsDataBreakpoints;
-    }
-    toString() {
-        return this.description;
-    }
-}
-class ExceptionBreakpoint extends BaseBreakpoint {
-    constructor(filter, label, enabled, supportsCondition, condition, description, conditionDescription, fallback = false) {
-        super(enabled, undefined, condition, undefined, generateUuid());
-        this.filter = filter;
-        this.label = label;
-        this.supportsCondition = supportsCondition;
-        this.description = description;
-        this.conditionDescription = conditionDescription;
-        this.fallback = fallback;
-        this.supportedSessions = ( (new Set()));
-    }
-    toJSON() {
-        const result = Object.create(null);
-        result.filter = this.filter;
-        result.label = this.label;
-        result.enabled = this.enabled;
-        result.supportsCondition = this.supportsCondition;
-        result.conditionDescription = this.conditionDescription;
-        result.condition = this.condition;
-        result.fallback = this.fallback;
-        result.description = this.description;
-        return result;
-    }
-    setSupportedSession(sessionId, supported) {
-        if (supported) {
-            this.supportedSessions.add(sessionId);
-        }
-        else {
-            this.supportedSessions.delete(sessionId);
-        }
-    }
-    setFallback(isFallback) {
-        this.fallback = isFallback;
-    }
-    get supported() {
-        return true;
-    }
-    isSupportedSession(sessionId) {
-        return sessionId ? ( (this.supportedSessions.has(sessionId))) : this.fallback;
-    }
-    matches(filter) {
-        return this.filter === filter.filter && this.label === filter.label && this.supportsCondition === !!filter.supportsCondition && this.conditionDescription === filter.conditionDescription && this.description === filter.description;
-    }
-    toString() {
-        return this.label;
-    }
-}
-class InstructionBreakpoint extends BaseBreakpoint {
-    constructor(instructionReference, offset, canPersist, enabled, hitCondition, condition, logMessage, id = generateUuid()) {
-        super(enabled, hitCondition, condition, logMessage, id);
-        this.instructionReference = instructionReference;
-        this.offset = offset;
-        this.canPersist = canPersist;
-    }
-    toJSON() {
-        const result = super.toJSON();
-        result.instructionReference = this.instructionReference;
-        result.offset = this.offset;
-        return result;
-    }
-    get supported() {
-        if (!this.data) {
-            return true;
-        }
-        return this.data.supportsInstructionBreakpoints;
-    }
-    toString() {
-        return this.instructionReference;
-    }
-}
-class ThreadAndSessionIds {
-    constructor(sessionId, threadId) {
-        this.sessionId = sessionId;
-        this.threadId = threadId;
-    }
-    getId() {
-        return `${this.sessionId}:${this.threadId}`;
-    }
-}
-let DebugModel = class DebugModel extends Disposable {
-    constructor(debugStorage, textFileService, uriIdentityService, logService) {
-        super();
-        this.textFileService = textFileService;
-        this.uriIdentityService = uriIdentityService;
-        this.logService = logService;
-        this.schedulers = ( (new Map()));
-        this.breakpointsActivated = true;
-        this._onDidChangeBreakpoints = this._register(( (new Emitter())));
-        this._onDidChangeCallStack = this._register(( (new Emitter())));
-        this._onDidChangeWatchExpressions = this._register(( (new Emitter())));
-        this._register(autorun(reader => {
-            this.breakpoints = debugStorage.breakpoints.read(reader);
-            this.functionBreakpoints = debugStorage.functionBreakpoints.read(reader);
-            this.exceptionBreakpoints = debugStorage.exceptionBreakpoints.read(reader);
-            this.dataBreakpoints = debugStorage.dataBreakpoints.read(reader);
-            this._onDidChangeBreakpoints.fire(undefined);
-        }));
-        this._register(autorun(reader => {
-            this.watchExpressions = debugStorage.watchExpressions.read(reader);
-            this._onDidChangeWatchExpressions.fire(undefined);
-        }));
-        this.instructionBreakpoints = [];
-        this.sessions = [];
-    }
-    getId() {
-        return 'root';
-    }
-    getSession(sessionId, includeInactive = false) {
-        if (sessionId) {
-            return this.getSessions(includeInactive).find(s => s.getId() === sessionId);
-        }
-        return undefined;
-    }
-    getSessions(includeInactive = false) {
-        return this.sessions.filter(s => includeInactive || s.state !== 0 );
-    }
-    addSession(session) {
-        this.sessions = this.sessions.filter(s => {
-            if (s.getId() === session.getId()) {
-                return false;
-            }
-            if (s.state === 0  && s.configuration.name === session.configuration.name) {
-                return false;
-            }
-            return true;
-        });
-        let i = 1;
-        while (( (this.sessions.some(s => s.getLabel() === session.getLabel())))) {
-            session.setName(`${session.configuration.name} ${++i}`);
-        }
-        let index = -1;
-        if (session.parentSession) {
-            index = findLastIndex(this.sessions, s => s.parentSession === session.parentSession || s === session.parentSession);
-        }
-        if (index >= 0) {
-            this.sessions.splice(index + 1, 0, session);
-        }
-        else {
-            this.sessions.push(session);
-        }
-        this._onDidChangeCallStack.fire(undefined);
-    }
-    get onDidChangeBreakpoints() {
-        return this._onDidChangeBreakpoints.event;
-    }
-    get onDidChangeCallStack() {
-        return this._onDidChangeCallStack.event;
-    }
-    get onDidChangeWatchExpressions() {
-        return this._onDidChangeWatchExpressions.event;
-    }
-    rawUpdate(data) {
-        const session = this.sessions.find(p => p.getId() === data.sessionId);
-        if (session) {
-            session.rawUpdate(data);
-            this._onDidChangeCallStack.fire(undefined);
-        }
-    }
-    clearThreads(id, removeThreads, reference = undefined) {
-        const session = this.sessions.find(p => p.getId() === id);
-        this.schedulers.forEach(entry => {
-            entry.scheduler.dispose();
-            entry.completeDeferred.complete();
-        });
-        this.schedulers.clear();
-        if (session) {
-            session.clearThreads(removeThreads, reference);
-            this._onDidChangeCallStack.fire(undefined);
-        }
-    }
-    async fetchCallstack(thread, levels) {
-        if (thread.reachedEndOfCallStack) {
-            return;
-        }
-        const totalFrames = thread.stoppedDetails?.totalFrames;
-        const remainingFrames = (typeof totalFrames === 'number') ? (totalFrames - thread.getCallStack().length) : undefined;
-        if (!levels || (remainingFrames && levels > remainingFrames)) {
-            levels = remainingFrames;
-        }
-        if (levels && levels > 0) {
-            await thread.fetchCallStack(levels);
-            this._onDidChangeCallStack.fire();
-        }
-        return;
-    }
-    refreshTopOfCallstack(thread) {
-        if (thread.session.capabilities.supportsDelayedStackTraceLoading) {
-            let topCallStack = Promise.resolve();
-            const wholeCallStack = ( (new Promise((c, e) => {
-                topCallStack = thread.fetchCallStack(1).then(() => {
-                    if (!( (this.schedulers.has(thread.getId())))) {
-                        const deferred = ( (new DeferredPromise()));
-                        this.schedulers.set(thread.getId(), {
-                            completeDeferred: deferred,
-                            scheduler: ( (new RunOnceScheduler(() => {
-                                thread.fetchCallStack(19).then(() => {
-                                    const stale = thread.getStaleCallStack();
-                                    const current = thread.getCallStack();
-                                    let bottomOfCallStackChanged = stale.length !== current.length;
-                                    for (let i = 1; i < stale.length && !bottomOfCallStackChanged; i++) {
-                                        bottomOfCallStackChanged = !stale[i].equals(current[i]);
-                                    }
-                                    if (bottomOfCallStackChanged) {
-                                        this._onDidChangeCallStack.fire();
-                                    }
-                                }).finally(() => {
-                                    deferred.complete();
-                                    this.schedulers.delete(thread.getId());
-                                });
-                            }, 420)))
-                        });
-                    }
-                    const entry = this.schedulers.get(thread.getId());
-                    entry.scheduler.schedule();
-                    entry.completeDeferred.p.then(c, e);
-                    this._onDidChangeCallStack.fire();
-                });
-            })));
-            return { topCallStack, wholeCallStack };
-        }
-        const wholeCallStack = thread.fetchCallStack();
-        return { wholeCallStack, topCallStack: wholeCallStack };
-    }
-    getBreakpoints(filter) {
-        if (filter) {
-            const uriStr = filter.uri?.toString();
-            const originalUriStr = filter.originalUri?.toString();
-            return this.breakpoints.filter(bp => {
-                if (uriStr && ( (bp.uri.toString())) !== uriStr) {
-                    return false;
-                }
-                if (originalUriStr && ( (bp.originalUri.toString())) !== originalUriStr) {
-                    return false;
-                }
-                if (filter.lineNumber && bp.lineNumber !== filter.lineNumber) {
-                    return false;
-                }
-                if (filter.column && bp.column !== filter.column) {
-                    return false;
-                }
-                if (filter.enabledOnly && (!this.breakpointsActivated || !bp.enabled)) {
-                    return false;
-                }
-                return true;
-            });
-        }
-        return this.breakpoints;
-    }
-    getFunctionBreakpoints() {
-        return this.functionBreakpoints;
-    }
-    getDataBreakpoints() {
-        return this.dataBreakpoints;
-    }
-    getExceptionBreakpoints() {
-        return this.exceptionBreakpoints;
-    }
-    getExceptionBreakpointsForSession(sessionId) {
-        return this.exceptionBreakpoints.filter(ebp => ebp.isSupportedSession(sessionId));
-    }
-    getInstructionBreakpoints() {
-        return this.instructionBreakpoints;
-    }
-    setExceptionBreakpointsForSession(sessionId, data) {
-        if (data) {
-            let didChangeBreakpoints = false;
-            data.forEach(d => {
-                let ebp = this.exceptionBreakpoints.filter((exbp) => exbp.matches(d)).pop();
-                if (!ebp) {
-                    didChangeBreakpoints = true;
-                    ebp = ( (new ExceptionBreakpoint(
-                        d.filter,
-                        d.label,
-                        !!d.default,
-                        !!d.supportsCondition,
-                        undefined ,
-                        d.description,
-                        d.conditionDescription
-                    )));
-                    this.exceptionBreakpoints.push(ebp);
-                }
-                ebp.setSupportedSession(sessionId, true);
-            });
-            if (didChangeBreakpoints) {
-                this._onDidChangeBreakpoints.fire(undefined);
-            }
-        }
-    }
-    removeExceptionBreakpointsForSession(sessionId) {
-        this.exceptionBreakpoints.forEach(ebp => ebp.setSupportedSession(sessionId, false));
-    }
-    setExceptionBreakpointFallbackSession(sessionId) {
-        this.exceptionBreakpoints.forEach(ebp => ebp.setFallback(ebp.isSupportedSession(sessionId)));
-    }
-    setExceptionBreakpointCondition(exceptionBreakpoint, condition) {
-        exceptionBreakpoint.condition = condition;
-        this._onDidChangeBreakpoints.fire(undefined);
-    }
-    areBreakpointsActivated() {
-        return this.breakpointsActivated;
-    }
-    setBreakpointsActivated(activated) {
-        this.breakpointsActivated = activated;
-        this._onDidChangeBreakpoints.fire(undefined);
-    }
-    addBreakpoints(uri, rawData, fireEvent = true) {
-        const newBreakpoints = ( (rawData.map(rawBp => ( (new Breakpoint(
-            uri,
-            rawBp.lineNumber,
-            rawBp.column,
-            rawBp.enabled === false ? false : true,
-            rawBp.condition,
-            rawBp.hitCondition,
-            rawBp.logMessage,
-            undefined,
-            this.textFileService,
-            this.uriIdentityService,
-            this.logService,
-            rawBp.id
-        ))))));
-        this.breakpoints = this.breakpoints.concat(newBreakpoints);
-        this.breakpointsActivated = true;
-        this.sortAndDeDup();
-        if (fireEvent) {
-            this._onDidChangeBreakpoints.fire({ added: newBreakpoints, sessionOnly: false });
-        }
-        return newBreakpoints;
-    }
-    removeBreakpoints(toRemove) {
-        this.breakpoints = this.breakpoints.filter(bp => !( (toRemove.some(toRemove => toRemove.getId() === bp.getId()))));
-        this._onDidChangeBreakpoints.fire({ removed: toRemove, sessionOnly: false });
-    }
-    updateBreakpoints(data) {
-        const updated = [];
-        this.breakpoints.forEach(bp => {
-            const bpData = data.get(bp.getId());
-            if (bpData) {
-                bp.update(bpData);
-                updated.push(bp);
-            }
-        });
-        this.sortAndDeDup();
-        this._onDidChangeBreakpoints.fire({ changed: updated, sessionOnly: false });
-    }
-    setBreakpointSessionData(sessionId, capabilites, data) {
-        this.breakpoints.forEach(bp => {
-            if (!data) {
-                bp.setSessionData(sessionId, undefined);
-            }
-            else {
-                const bpData = data.get(bp.getId());
-                if (bpData) {
-                    bp.setSessionData(sessionId, toBreakpointSessionData(bpData, capabilites));
-                }
-            }
-        });
-        this.functionBreakpoints.forEach(fbp => {
-            if (!data) {
-                fbp.setSessionData(sessionId, undefined);
-            }
-            else {
-                const fbpData = data.get(fbp.getId());
-                if (fbpData) {
-                    fbp.setSessionData(sessionId, toBreakpointSessionData(fbpData, capabilites));
-                }
-            }
-        });
-        this.dataBreakpoints.forEach(dbp => {
-            if (!data) {
-                dbp.setSessionData(sessionId, undefined);
-            }
-            else {
-                const dbpData = data.get(dbp.getId());
-                if (dbpData) {
-                    dbp.setSessionData(sessionId, toBreakpointSessionData(dbpData, capabilites));
-                }
-            }
-        });
-        this.exceptionBreakpoints.forEach(ebp => {
-            if (!data) {
-                ebp.setSessionData(sessionId, undefined);
-            }
-            else {
-                const ebpData = data.get(ebp.getId());
-                if (ebpData) {
-                    ebp.setSessionData(sessionId, toBreakpointSessionData(ebpData, capabilites));
-                }
-            }
-        });
-        this.instructionBreakpoints.forEach(ibp => {
-            if (!data) {
-                ibp.setSessionData(sessionId, undefined);
-            }
-            else {
-                const ibpData = data.get(ibp.getId());
-                if (ibpData) {
-                    ibp.setSessionData(sessionId, toBreakpointSessionData(ibpData, capabilites));
-                }
-            }
-        });
-        this._onDidChangeBreakpoints.fire({
-            sessionOnly: true
-        });
-    }
-    getDebugProtocolBreakpoint(breakpointId, sessionId) {
-        const bp = this.breakpoints.find(bp => bp.getId() === breakpointId);
-        if (bp) {
-            return bp.getDebugProtocolBreakpoint(sessionId);
-        }
-        return undefined;
-    }
-    sortAndDeDup() {
-        this.breakpoints = this.breakpoints.sort((first, second) => {
-            if (( (first.uri.toString())) !== ( (second.uri.toString()))) {
-                return resources.basenameOrAuthority(first.uri).localeCompare(resources.basenameOrAuthority(second.uri));
-            }
-            if (first.lineNumber === second.lineNumber) {
-                if (first.column && second.column) {
-                    return first.column - second.column;
-                }
-                return 1;
-            }
-            return first.lineNumber - second.lineNumber;
-        });
-        this.breakpoints = distinct(this.breakpoints, bp => `${( ( bp.uri.toString()))}:${bp.lineNumber}:${bp.column}`);
-    }
-    setEnablement(element, enable) {
-        if (element instanceof Breakpoint || element instanceof FunctionBreakpoint || element instanceof ExceptionBreakpoint || element instanceof DataBreakpoint || element instanceof InstructionBreakpoint) {
-            const changed = [];
-            if (element.enabled !== enable && (element instanceof Breakpoint || element instanceof FunctionBreakpoint || element instanceof DataBreakpoint || element instanceof InstructionBreakpoint)) {
-                changed.push(element);
-            }
-            element.enabled = enable;
-            if (enable) {
-                this.breakpointsActivated = true;
-            }
-            this._onDidChangeBreakpoints.fire({ changed: changed, sessionOnly: false });
-        }
-    }
-    enableOrDisableAllBreakpoints(enable) {
-        const changed = [];
-        this.breakpoints.forEach(bp => {
-            if (bp.enabled !== enable) {
-                changed.push(bp);
-            }
-            bp.enabled = enable;
-        });
-        this.functionBreakpoints.forEach(fbp => {
-            if (fbp.enabled !== enable) {
-                changed.push(fbp);
-            }
-            fbp.enabled = enable;
-        });
-        this.dataBreakpoints.forEach(dbp => {
-            if (dbp.enabled !== enable) {
-                changed.push(dbp);
-            }
-            dbp.enabled = enable;
-        });
-        this.instructionBreakpoints.forEach(ibp => {
-            if (ibp.enabled !== enable) {
-                changed.push(ibp);
-            }
-            ibp.enabled = enable;
-        });
-        if (enable) {
-            this.breakpointsActivated = true;
-        }
-        this._onDidChangeBreakpoints.fire({ changed: changed, sessionOnly: false });
-    }
-    addFunctionBreakpoint(functionName, id) {
-        const newFunctionBreakpoint = ( (new FunctionBreakpoint(functionName, true, undefined, undefined, undefined, id)));
-        this.functionBreakpoints.push(newFunctionBreakpoint);
-        this._onDidChangeBreakpoints.fire({ added: [newFunctionBreakpoint], sessionOnly: false });
-        return newFunctionBreakpoint;
-    }
-    updateFunctionBreakpoint(id, update) {
-        const functionBreakpoint = this.functionBreakpoints.find(fbp => fbp.getId() === id);
-        if (functionBreakpoint) {
-            if (typeof update.name === 'string') {
-                functionBreakpoint.name = update.name;
-            }
-            if (typeof update.condition === 'string') {
-                functionBreakpoint.condition = update.condition;
-            }
-            if (typeof update.hitCondition === 'string') {
-                functionBreakpoint.hitCondition = update.hitCondition;
-            }
-            this._onDidChangeBreakpoints.fire({ changed: [functionBreakpoint], sessionOnly: false });
-        }
-    }
-    removeFunctionBreakpoints(id) {
-        let removed;
-        if (id) {
-            removed = this.functionBreakpoints.filter(fbp => fbp.getId() === id);
-            this.functionBreakpoints = this.functionBreakpoints.filter(fbp => fbp.getId() !== id);
-        }
-        else {
-            removed = this.functionBreakpoints;
-            this.functionBreakpoints = [];
-        }
-        this._onDidChangeBreakpoints.fire({ removed, sessionOnly: false });
-    }
-    addDataBreakpoint(label, dataId, canPersist, accessTypes, accessType) {
-        const newDataBreakpoint = ( (new DataBreakpoint(
-            label,
-            dataId,
-            canPersist,
-            true,
-            undefined,
-            undefined,
-            undefined,
-            accessTypes,
-            accessType
-        )));
-        this.dataBreakpoints.push(newDataBreakpoint);
-        this._onDidChangeBreakpoints.fire({ added: [newDataBreakpoint], sessionOnly: false });
-    }
-    removeDataBreakpoints(id) {
-        let removed;
-        if (id) {
-            removed = this.dataBreakpoints.filter(fbp => fbp.getId() === id);
-            this.dataBreakpoints = this.dataBreakpoints.filter(fbp => fbp.getId() !== id);
-        }
-        else {
-            removed = this.dataBreakpoints;
-            this.dataBreakpoints = [];
-        }
-        this._onDidChangeBreakpoints.fire({ removed, sessionOnly: false });
-    }
-    addInstructionBreakpoint(address, offset, condition, hitCondition) {
-        const newInstructionBreakpoint = ( (new InstructionBreakpoint(address, offset, false, true, hitCondition, condition, undefined)));
-        this.instructionBreakpoints.push(newInstructionBreakpoint);
-        this._onDidChangeBreakpoints.fire({ added: [newInstructionBreakpoint], sessionOnly: true });
-    }
-    removeInstructionBreakpoints(address) {
-        let removed;
-        if (address) {
-            removed = this.instructionBreakpoints.filter(fbp => fbp.instructionReference === address);
-            this.instructionBreakpoints = this.instructionBreakpoints.filter(fbp => fbp.instructionReference !== address);
-        }
-        else {
-            removed = this.instructionBreakpoints;
-            this.instructionBreakpoints = [];
-        }
-        this._onDidChangeBreakpoints.fire({ removed, sessionOnly: false });
-    }
-    getWatchExpressions() {
-        return this.watchExpressions;
-    }
-    addWatchExpression(name) {
-        const we = ( (new Expression(name || '')));
-        this.watchExpressions.push(we);
-        this._onDidChangeWatchExpressions.fire(we);
-        return we;
-    }
-    renameWatchExpression(id, newName) {
-        const filtered = this.watchExpressions.filter(we => we.getId() === id);
-        if (filtered.length === 1) {
-            filtered[0].name = newName;
-            this._onDidChangeWatchExpressions.fire(filtered[0]);
-        }
-    }
-    removeWatchExpressions(id = null) {
-        this.watchExpressions = id ? this.watchExpressions.filter(we => we.getId() !== id) : [];
-        this._onDidChangeWatchExpressions.fire(undefined);
-    }
-    moveWatchExpression(id, position) {
-        const we = this.watchExpressions.find(we => we.getId() === id);
-        if (we) {
-            this.watchExpressions = this.watchExpressions.filter(we => we.getId() !== id);
-            this.watchExpressions = this.watchExpressions.slice(0, position).concat(we, this.watchExpressions.slice(position));
-            this._onDidChangeWatchExpressions.fire(undefined);
-        }
-    }
-    sourceIsNotAvailable(uri) {
-        this.sessions.forEach(s => {
-            const source = s.getSourceForUri(uri);
-            if (source) {
-                source.available = false;
-            }
-        });
-        this._onDidChangeCallStack.fire(undefined);
-    }
-};
-DebugModel = ( (__decorate([
-    ( (__param(1, ITextFileService))),
-    ( (__param(2, IUriIdentityService))),
-    ( (__param(3, ILogService)))
-], DebugModel)));
-export { BaseBreakpoint, Breakpoint, DataBreakpoint, DebugModel, Enablement, ErrorScope, ExceptionBreakpoint, Expression, ExpressionContainer, FunctionBreakpoint, InstructionBreakpoint, MemoryRegion, Scope, StackFrame, Thread, ThreadAndSessionIds, Variable, getUriForDebugMemory };