anchor.diff:     *     }
      *
      *     stringStream.transform(new DuplicationTransformer());
  +   *
  +   * The resulting stream is a broadcast stream if [source] is.
      */
     factory Stream.eventTransformed(Stream source,
                                     EventSink mapSink(EventSink<T> sink)) {
  
positive.code:    *
     * If you need to transform an error into a data event, use the more generic
     * [Stream.transform] to handle the event by writing a data event to
     * the output sink
     *
     * The returned stream is a broadcast stream if this stream is.
     */
    Stream<T> handleError(Function onError, { bool test(error) }) {
      return new _HandleErrorStream<T>(this, onError, test);
  
negative.code: /**
   * A source of asynchronous data events.
   *
   * A Stream provides a way to receive a sequence of events.
   * Each event is either a data event or an error event,
   * representing the result of a single computation.
   * When the events provided by a Stream have all been sent,
   * a single "done" event will mark the end.
   *
   * You can [listen] on a stream to make it start generating events,
   * and to set up listeners that receive the events.
   * When you listen, you receive a [StreamSubscription] object
   * which is the active object providing the events,
   * and which can be used to stop listening again,
   * or to temporarily pause events from the subscription.
   *
   * There are two kinds of streams: "Single-subscription" streams and
   * "broadcast" streams.
   *
   * *A single-subscription stream* allows only a single listener during the whole
   * lifetime of the stream.
   * It doesn't start generating events until it has a listener,
   * and it stops sending events when the listener is unsubscribed,
   * even if the source of events could still provide more.
   *
   * Listening twice on a single-subscription stream is not allowed, even after
   * the first subscription has been canceled.
   *
   * Single-subscription streams are generally used for streaming chunks of
   * larger contiguous data like file I/O.
   *
   * *A broadcast stream* allows any number of listeners, and it fires
   * its events when they are ready, whether there are listeners or not.
   *
   * Broadcast streams are used for independent events/observers.
   *
   * If several listeners want to listen to a single subscription stream,
   * use [asBroadcastStream] to create a broadcast stream on top of the
   * non-broadcast stream.
   *
   * On either kind of stream, stream transformationss, such as [where] and
   * [skip], return the same type of stream as the one the method was called on,
   * unless otherwise noted.
   *
   * When an event is fired, the listener(s) at that time will receive the event.
   * If a listener is added to a broadcast stream while an event is being fired,
   * that listener will not receive the event currently being fired.
   * If a listener is canceled, it immediately stops receiving events.
   *
   * When the "done" event is fired, subscribers are unsubscribed before
   * receiving the event. After the event has been sent, the stream has no
   * subscribers. Adding new subscribers to a broadcast stream after this point
   * is allowed, but they will just receive a new "done" event as soon
   * as possible.
   *
   * Stream subscriptions always respect "pause" requests. If necessary they need
   * to buffer their input, but often, and preferably, they can simply request
   * their input to pause too.
   *
   * The default implementation of [isBroadcast] returns false.
   * A broadcast stream inheriting from [Stream] must override [isBroadcast]
   * to return `true`.
   */
  abstract class Stream<T> {
    Stream();
  