// 初始化 Debugger
this.dap.on('initialize', params => this._onInitialize(params));
// 设置断点
this.dap.on('setBreakpoints', params => this._onSetBreakpoints(params));
// 设置异常断点
this.dap.on('setExceptionBreakpoints', params => this.setExceptionBreakpoints(params));
// 配置初始化完成事件
this.dap.on('configurationDone', () => this.configurationDone());
// 请求资源
this.dap.on('loadedSources', () => this._onLoadedSources());

public async setBreakpoints(
    params: Dap.SetBreakpointsParams,
    ids: number[],
  ): Promise<Dap.SetBreakpointsResult> {
    // 安装代码 SourceMap 文件
    if (!this._sourceMapHandlerInstalled && this._thread && params.breakpoints?.length) {
      await this._installSourceMapHandler(this._thread);
    }
    // ... 省略部分参数订正及等待相关进程初始化的过程
    // ... 省略合并已有的断点逻辑，同时移除未与调试进程绑定的断点
    if (thread && result.new.length) {
      // 为调试器添加断点
      this.ensureModuleEntryBreakpoint(thread, params.source);
      // 这里的 Promise.all 结构是为了确保设置断点过程中不会因为用户的某次 disabled 操作而丢失准确性
      // 相当于取了当前时刻有效的一份断点列表
      const currentList = getCurrent();
      const promise = Promise.all(
        result.new
          .filter(this._enabledFilter)
          .filter(bp => currentList?.includes(bp))
          // 实际断点设置逻辑
          .map(b => b.enable(thread)),
      );
      // 添加断点设置 promise 至 this._launchBlocker, 后续调试器依赖对 `launchBlocker` 方法来确保断点已经处理完毕
      this.addLaunchBlocker(Promise.race([delay(breakpointSetTimeout), promise]));
      await promise;
    }
    // 返回断点设置的 DAP 消息
    const dapBreakpoints = await Promise.all(result.list.map(b => b.toDap()));
    this._breakpointsStatisticsCalculator.registerBreakpoints(dapBreakpoints);
    // 更新当前断点状态
    delay(0).then(() => result.new.forEach(bp => bp.markSetCompleted()));
    return { breakpoints: dapBreakpoints };
  }

 public async enable(thread: Thread): Promise<void> {
    if (this.isEnabled) {
      return;
    }
    this.isEnabled = true;
    const promises: Promise<void>[] = [this._setPredicted(thread)];
    const source = this._manager._sourceContainer.source(this.source);
    if (!source || !(source instanceof SourceFromMap)) {
      promises.push(
        // 当不存在资源或非 SourceMap 资源时
        // 根据断点位置、代码偏移量计算最终断点位置后在调试器文件路径下断点
        this._setByPath(thread, uiToRawOffset(this.originalPosition, source?.runtimeScriptOffset)),
      );
    }
    await Promise.all(promises);
    ...
  }

  protected async _setByPath(thread: Thread, lineColumn: LineColumn): Promise<void> {
    const sourceByPath = this._manager._sourceContainer.source({ path: this.source.path });
    // ... 忽略对已经映射到本地的资源的处理
    if (this.source.path) {
      const urlRegexp =
        await this._manager._sourceContainer.sourcePathResolver.absolutePathToUrlRegexp(
          this.source.path,
        );
      if (!urlRegexp) {
        return;
      }
     // 通过正则表达式设置断点
      await this._setByUrlRegexp(thread, urlRegexp, lineColumn);
    } else {
      const source = this._manager._sourceContainer.source(this.source);
      const url = source?.url;
      if (!url) {
        return;
      }
      // 直接通过路径设置断点
      await this._setByUrl(thread, url, lineColumn);
      if (this.source.path !== url && this.source.path !== undefined) {
        await this._setByUrl(thread, absolutePathToFileUrl(this.source.path), lineColumn);
      }
    }

  protected async _setByUrlRegexp(
    thread: Thread,
    urlRegex: string,
    lineColumn: LineColumn,
  ): Promise<void> {
    lineColumn = base1To0(lineColumn);
    const previous = this.hasSetOnLocationByRegexp(urlRegex, lineColumn);
    if (previous) {
      if (previous.state === CdpReferenceState.Pending) {
        await previous.done;
      }
      return;
    }
    // 设置断点
    return this._setAny(thread, {
      urlRegex,
      condition: this.getBreakCondition(),
      ...lineColumn,
    });
  }

 private send(typ: NodeV8MessageType, message: NodeV8Message) : void {
  message.type = typ;
  message.seq = this._sequence++;
  const json = JSON.stringify(message);
  const data = 'Content-Length: ' + Buffer.byteLength(json, 'utf8') + '\r\n\r\n' + json;
  if (this._writableStream) {
   this._writableStream.write(data);
  }
 }

{
  // 调试进程 IPC 通信地址
  "inspectorIpc":"/var/folders/qh/r2tjb8vd1z3_qtlnxy47b4vh0000gn/T/node-cdp.33805-2.sock",
  // 一些配置
  "deferredMode":false,
  "waitForDebugger":"",
  "execPath":".../node",
  "onlyEntrypoint":false,
  "autoAttachMode":"always",
  // 文件回调地址，如果存在，在调试进程中的打印的日志将会写入到该文件中
  "fileCallback":"/var/folders/qh/r2tjb8vd1z3_qtlnxy47b4vh0000gn/T/node-debug-callback-d2db3d91a6f5ae91"
}

fs.readdirSync(path.dirname(inspectorIpc)).includes(path.basename(inspectorIpc));

(() => {
  ...
  // 当进程执行时传入了 `--inspect` 时，inspector.url() 可以获取到当前的调试地址，命令行情况需要额外处理
  const info: IAutoAttachInfo = {
    ipcAddress: env.inspectorIpc || '',
    pid: String(process.pid),
    telemetry,
    scriptName: process.argv[1],
    inspectorURL: inspector.url() as string,
    waitForDebugger: true,
    ownId,
    openerId: env.openerId,
  };
  // 当需要立即启动调试时，执行 watchdog 程序监听进程创建
  if (mode === Mode.Immediate) {
    // 代码见：https://github.com/microsoft/vscode-js-debug/blob/b056fbb86ef2e2e5aa99663ff18411c80bdac3c5/src/targets/node/bootloader.ts#L276
    spawnWatchdog(env.execPath || process.execPath, info);
  }
  ...
})();
function spawnWatchdog(execPath: string, watchdogInfo: IWatchdogInfo) {
  const p = spawn(execPath, [watchdogPath], {
    env: {
      NODE_INSPECTOR_INFO: JSON.stringify(watchdogInfo),
      NODE_SKIP_PLATFORM_CHECK: process.env.NODE_SKIP_PLATFORM_CHECK,
    },
    stdio: 'ignore',
    detached: true,
  });
  p.unref();
  return p;
}

const info: IWatchdogInfo = JSON.parse(process.env.NODE_INSPECTOR_INFO!);
(async () => {
  process.on('exit', () => {
    logger.info(LogTag.Runtime, 'Process exiting');
    logger.dispose();
    if (info.pid && !info.dynamicAttach && (!wd || wd.isTargetAlive)) {
      process.kill(Number(info.pid));
    }
  });
  const wd = await WatchDog.attach(info);
  wd.onEnd(() => process.exit());
})();

class WatchDog {
  ...
  // 链接本地 IPC 通信地址，即前面从环境变量中获取的 inspectorIpc
  public static async attach(info: IWatchdogInfo) {
    const pipe: net.Socket = await new Promise((resolve, reject) => {
      const cnx: net.Socket = net.createConnection(info.ipcAddress, () => resolve(cnx));
      cnx.on('error', reject);
    });
    const server = new RawPipeTransport(Logger.null, pipe);
    return new WatchDog(info, server);
  }
  constructor(private readonly info: IWatchdogInfo, private readonly server: ITransport) {
    this.listenToServer();
  }
  // 链接 Server 后，发送第一条 `Target.targetCreated` 通知调试进程已经可以开始调试
  private listenToServer() {
    const { server, targetInfo } = this;
    server.send(JSON.stringify({ method: 'Target.targetCreated', params: { targetInfo } }));
    server.onMessage(async ([data]) => {
      // Fast-path to check if we might need to parse it:
      if (
        this.target &&
        !data.includes(Method.AttachToTarget) &&
        !data.includes(Method.DetachFromTarget)
      ) {
        // 向 inspectorUrl 建立的链接发送消息
        this.target.send(data);
        return;
      }
      // 解析消息体
      const result = await this.execute(data);
      if (result) {
        // 向调试进程发送消息
        server.send(JSON.stringify(result));
      }
    });
    server.onEnd(() => {
      this.disposeTarget();
      this.onEndEmitter.fire({ killed: this.gracefulExit, code: this.gracefulExit ? 0 : 1 });
    });
  }
  ...
}

export class TerminalLinkHandler implements vscode.TerminalLinkProvider<ITerminalLink>, IDisposable {
  // 根据给定的 Terminal 获取其内容中可被点击的 Link 数组，配置其基础信息
  public provideTerminalLinks(context: vscode.TerminalLinkContext): ITerminalLink[] {
    switch (this.baseConfiguration.enabled) {
      case 'off':
        return [];
      case 'always':
        break;
      case 'on':
      default:
        if (!this.enabledTerminals.has(context.terminal)) {
          return [];
        }
    }
    const links: ITerminalLink[] = [];
    for (const link of findLink(context.line, 'url')) {
      let start = -1;
      while ((start = context.line.indexOf(link.value, start + 1)) !== -1) {
        let uri: URL;
        try {
          uri = new URL(link.href);
        } catch {
          continue;
        }
        // hack for https://github.com/Soapbox/linkifyjs/issues/317
        if (
          uri.protocol === Protocol.Http &&
          !link.value.startsWith(Protocol.Http) &&
          !isLoopbackIp(uri.hostname)
        ) {
          uri.protocol = Protocol.Https;
        }
        if (uri.protocol !== Protocol.Http && uri.protocol !== Protocol.Https) {
          continue;
        }
        links.push({
          startIndex: start,
          length: link.value.length,
          tooltip: localize('terminalLinkHover.debug', 'Debug URL'),
          target: uri,
          workspaceFolder: getCwd()?.index,
        });
      }
    }
    return links;
  }
  /**
   * 处理具体点击链接后的操作
   */
  public async handleTerminalLink(terminal: ITerminalLink): Promise<void> {
    if (!(await this.handleTerminalLinkInner(terminal))) {
      vscode.env.openExternal(vscode.Uri.parse(terminal.target.toString()));
    }
  }    
}