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 34 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));
+      new _MatchingStream(
+          this.where((event) => event.target.matchesWithAncestors(selector)),
+          selector);
 }
 
 /**
  * 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) =>

[blois, 2013/10/09 22:25:44]

how about =>
this.where((event) => event.target.matchesWithAncestors(selector)).map((e) {
 e._selector = selector;
 return e;
});

Rather than adding the new class?

[Emily Fortuna, 2013/10/09 22:39:18]

Good point. fixed.

-      this.where((event) => event.target.matchesWithAncestors(selector));
+    new _MatchingStream(
+        this.where((event) => event.target.matchesWithAncestors(selector)),
+        selector);
 
   // 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)})
       => _stream;
   bool get isBroadcast => true;
 }
 
 /**
+ * A stream that keeps track of what CSS selectors it used to collect element
+ * events for event delegation.
+ */
+class _MatchingStream<T extends Event> extends Stream<T> {
+  Stream<T> _stream;
+  String selector;
+
+  _MatchingStream(Stream this._stream, String this.selector);
+
+  // 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((e) { e._selector = selector; return onData(e); },
+          onError: onError,
+          onDone: onDone,
+          cancelOnError: cancelOnError);
+}
+
+/**
  * A stream of custom events, which enables the user to "fire" (add) their own
  * custom events to a stream.
  */
 abstract class CustomStream<T extends Event> implements Stream<T> {
   /**
    * Add the following custom event to the stream for dispatching to interested
    * listeners.
    */
   void add(T event);
 }
@@ skipping 279 matching lines @@
 
   ElementStream<T> _forElementList(ElementList e,
       {bool useCapture: false}) {
     return new _ElementListEventStreamImpl(e, _eventTypeGetter(e), useCapture);
   }
 
   String getEventType(EventTarget target) {
     return _eventTypeGetter(target);
   }
 }