anchor.diff:      return positions;
     }
   }
  +
  +class ScriptCache {
  +  ScriptCache();
  +
  +  Map<String, Script> _scripts = {};
  +  final Map<String, Future<Script>> _inProgress = {};
  +
  +  /// Return a cached [Script] for the given [ScriptRef], returning null
  +  /// if there is no cached [Script].
  +  Script getScriptCached(ScriptRef scriptRef) {
  +    return _scripts[scriptRef?.id];
  +  }
  +
  +  /// Retrieve the [Script] for the given [ScriptRef].
  +  ///
  +  /// This caches the script lookup for future invocations.
  +  Future<Script> getScript(
  +      VmService vmService, IsolateRef isolateRef, ScriptRef scriptRef) {
  +    if (_scripts.containsKey(scriptRef.id)) {
  +      return Future.value(_scripts[scriptRef.id]);
  +    }
  +
  +    if (_inProgress.containsKey(scriptRef.id)) {
  +      return _inProgress[scriptRef.id];
  +    }
  +
  +    // We make a copy here as the future could complete after a clear()
  +    // operation is performed.
  +    final scripts = _scripts;
  +
  +    final Future<Script> scriptFuture = vmService
  +        .getObject(isolateRef.id, scriptRef.id)
  +        .then((obj) => obj as Script);
  +    _inProgress[scriptRef.id] = scriptFuture;
  +
  +    unawaited(scriptFuture.then((script) {
  +      scripts[scriptRef.id] = script;
  +    }));
  +
  +    return scriptFuture;
  +  }
  +
  +  void clear() {
  +    _scripts = {};
  +    _inProgress.clear();
  +  }
  +}
  
positive.code:     if (isolate.pauseEvent != null &&
          isolate.pauseEvent.kind != EventKind.kResume) {
        _lastEvent = isolate.pauseEvent;
        _reportedException = isolate.pauseEvent.exception;
        await _pause(true);
      }
  
      _breakpoints.value = isolate.breakpoints;
  
negative.code:     switch (event.kind) {
        case EventKind.kResume:
          await _pause(false);
          break;
        case EventKind.kPauseStart:
        case EventKind.kPauseExit:
  