anchor.diff:          yield tv;
         }
       }
  -    isolate.kill();
  +    _isolate.kill();
       final done = await isolateExit.first;
       await isolateExit.close();
  +  }
  +
  +  /// See the documentation for IsolateStream.kill(int).
  +  void kill(int priority) {
  +    if (priority == null) {
  +      priority = Isolate.beforeNextEvent;
  +    }
  +    _killedWith = priority;
  +    // Record the priority in case _isolate is null -- see _generate().
  +    if (_isolate != null) {
  +      _isolate.kill(priority: priority);
  +    }
     }
   
     /// Initialize our run inside the isolate.
  
positive.code: ///  generating function, if needed, so that the Send/ReceivePort buffer
  ///  doesn't get overly large.
  class IsolateStream<T, A> extends DelegatingStream<T> {
    /// Create a new stream with the given generating function, which
    /// takes an argument of type A, and produces an Iterator<T>.
    /// function should give an estimate of the size of an object of type T,
  
negative.code:       A generatorArg,
        int Function(T value) sizeOf,
        {int maxBuf})
        : this._fromSink(
              _IsolateStreamGenerator<T, A>(generatorArg, sizeOf, maxBuf),
              generator);
  
    IsolateStream._fromSink(this._isolateManager,
        Future<void> Function(A, IsolateGeneratorSink<dynamic>) generator)
        : super(_isolateManager.generateFromSink(generator));
  
    /// Request our generating to shut down, by calling Isolate.kill with the
    /// given argument.  This should not normally be necessary, but it may be
    /// useful to clean up under exceptional circumstances.
    void kill({int priority: Isolate.beforeNextEvent}) =>
        _isolateManager.kill(priority);
  }
  
  /// A helper to do the work of generating a Stream<T> in another isolate.
  