Method _createPausedDetails

src/adapter/threads.ts:1410–1592

(event: Cdp.Debugger.PausedEvent)

  }

  private async _createPausedDetails(event: Cdp.Debugger.PausedEvent): Promise<IPausedDetails> {
    // When hitting breakpoint in compiled source, we ignore source maps during the stepping
    // sequence (or exceptions) until user resumes or hits another breakpoint-alike pause.
    // TODO: this does not work for async stepping just yet.
    const sameDebuggingSequence = event.reason === 'assert'
      || event.reason === 'exception'
      || event.reason === 'promiseRejection'
      || event.reason === 'other'
      || event.reason === 'ambiguous';

    const hitBreakpoints =
      event.hitBreakpoints?.filter(bp => !this._breakpointManager.isEntrypointCdpBreak(bp)) || [];

    if (hitBreakpoints.length || !sameDebuggingSequence) {
      this._sourceContainer.clearDisabledSourceMaps();
    }

    if (event.hitBreakpoints && this._sourceMapDisabler) {
      for (const sourceToDisable of this._sourceMapDisabler(event.hitBreakpoints)) {
        this._sourceContainer.disableSourceMapForSource(sourceToDisable);
      }
    }

    const stackTrace = StackTrace.fromDebugger(
      this,
      event.callFrames,
      event.asyncStackTrace,
      event.asyncStackTraceId,
    );

    if (event.data?.__rewriteAs === 'breakpoint') {
      return {
        thread: this,
        event,
        stackTrace,
        reason: 'breakpoint',
        description: l10n.t('Paused on breakpoint'),
      };
    }

    if (event.data?.__rewriteAs === 'step') {
      return {
        thread: this,
        event,
        stackTrace,
        reason: 'step',
        description: l10n.t('Paused'),
      };
    }

    switch (event.reason) {
      case 'assert':
        return {
          thread: this,
          event,
          stackTrace,
          reason: 'exception',
          description: l10n.t('Paused on assert'),