Add "matchingTarget" function to Event, which is the Element that matched the CSS value selector.

tools/dom/src/EventStreamProvider.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of html;
 
 /**
  * Adapter for exposing DOM events as Dart streams.
  */
 class _EventStream<T extends Event> extends Stream<T> {
@@ skipping 33 matching lines @@
 
 /**
  * Adapter for exposing DOM Element events as streams, while also allowing
  * event delegation.
  */
 class _ElementEventStreamImpl<T extends Event> extends _EventStream<T>
     implements ElementStream<T> {
   _ElementEventStreamImpl(target, eventType, useCapture) :
       super(target, eventType, useCapture);
 
-  Stream<T> matches(String selector) =>
-      this.where((event) => event.target.matchesWithAncestors(selector));
+  Stream<T> matches(String selector) => this.where(
+      (event) => event.target.matchesWithAncestors(selector)).map((e) {
+        e._selector = selector;
+        return e;
+      });
 }
 
 /**
  * Adapter for exposing events on a collection of DOM Elements as streams,
  * while also allowing event delegation.
  */
 class _ElementListEventStreamImpl<T extends Event> extends Stream<T>
     implements ElementStream<T> {
   final _StreamPool _pool;
   Stream<T> _stream;
 
   _ElementListEventStreamImpl(targetList, eventType, useCapture) :
       _pool = new _StreamPool.broadcast() {
     for (Element target in targetList) {
       var stream = new _EventStream(target, eventType, useCapture);
       _pool.add(stream);
     }
     _stream = _pool.stream;
   }
 
-  Stream<T> matches(String selector) =>
-      this.where((event) => event.target.matchesWithAncestors(selector));
+  Stream<T> matches(String selector) => this.where(
+      (event) => event.target.matchesWithAncestors(selector)).map((e) {
+        e._selector = selector;
+        return e;
+      });
 
   // Delegate all regular Stream behavor to our wrapped Stream.
   StreamSubscription<T> listen(void onData(T event),
       { void onError(error),
         void onDone(),
         bool cancelOnError}) =>
       _stream.listen(onData, onError: onError, onDone: onDone,
           cancelOnError: cancelOnError);
   Stream<T> asBroadcastStream({void onListen(StreamSubscription subscription),
                                void onCancel(StreamSubscription subscription)})
@@ skipping 294 matching lines @@
 
   ElementStream<T> _forElementList(ElementList e,
       {bool useCapture: false}) {
     return new _ElementListEventStreamImpl(e, _eventTypeGetter(e), useCapture);
   }
 
   String getEventType(EventTarget target) {
     return _eventTypeGetter(target);
   }
 }