Adding streams to dart:html.

sdk/lib/html/dart2js/html_dart2js.dart

 library html;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:html_common';
 import 'dart:indexed_db';
 import 'dart:isolate';
 import 'dart:json' as json;
 import 'dart:math';
 import 'dart:svg' as svg;
@@ skipping 39 matching lines @@
 
 spawnDomFunction(f) => IsolateNatives.spawnDomFunction(f);
 // Copyright (c) 2012, 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.
 
 
 /// @domName AbstractWorker; @docsEditable true
 class AbstractWorker extends EventTarget native "*AbstractWorker" {
 
+  static const EventStreamProvider<Event> errorEvent = const EventStreamProvider<Event>('error');
+
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   AbstractWorkerEvents get on =>
     new AbstractWorkerEvents(this);
 
   /// @domName AbstractWorker.addEventListener; @docsEditable true
   @JSName('addEventListener')
   void $dom_addEventListener(String type, EventListener listener, [bool useCapture]) native;
 
   /// @domName AbstractWorker.dispatchEvent; @docsEditable true
   @JSName('dispatchEvent')
   bool $dom_dispatchEvent(Event evt) native;
 
   /// @domName AbstractWorker.removeEventListener; @docsEditable true
   @JSName('removeEventListener')
   void $dom_removeEventListener(String type, EventListener listener, [bool useCapture]) native;
+
+  Stream<Event> get onError => errorEvent.forTarget(this);
 }
 
 /// @docsEditable true
 class AbstractWorkerEvents extends Events {
   /// @docsEditable true
   AbstractWorkerEvents(EventTarget _ptr) : super(_ptr);
 
   /// @docsEditable true
   EventListenerList get error => this['error'];
 }
@@ skipping 78 matching lines @@
   final num elapsedTime;
 }
 // Copyright (c) 2012, 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.
 
 
 /// @domName DOMApplicationCache; @docsEditable true
 class ApplicationCache extends EventTarget native "*DOMApplicationCache" {
 
+  static const EventStreamProvider<Event> cachedEvent = const EventStreamProvider<Event>('cached');
+
+  static const EventStreamProvider<Event> checkingEvent = const EventStreamProvider<Event>('checking');
+
+  static const EventStreamProvider<Event> downloadingEvent = const EventStreamProvider<Event>('downloading');
+
+  static const EventStreamProvider<Event> errorEvent = const EventStreamProvider<Event>('error');
+
+  static const EventStreamProvider<Event> noUpdateEvent = const EventStreamProvider<Event>('noupdate');
+
+  static const EventStreamProvider<Event> obsoleteEvent = const EventStreamProvider<Event>('obsolete');
+
+  static const EventStreamProvider<Event> progressEvent = const EventStreamProvider<Event>('progress');
+
+  static const EventStreamProvider<Event> updateReadyEvent = const EventStreamProvider<Event>('updateready');
+
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   ApplicationCacheEvents get on =>
     new ApplicationCacheEvents(this);
 
   static const int CHECKING = 2;
 
   static const int DOWNLOADING = 3;
 
   static const int IDLE = 1;
 
@@ skipping 19 matching lines @@
 
   /// @domName DOMApplicationCache.removeEventListener; @docsEditable true
   @JSName('removeEventListener')
   void $dom_removeEventListener(String type, EventListener listener, [bool useCapture]) native;
 
   /// @domName DOMApplicationCache.swapCache; @docsEditable true
   void swapCache() native;
 
   /// @domName DOMApplicationCache.update; @docsEditable true
   void update() native;
+
+  Stream<Event> get onCached => cachedEvent.forTarget(this);
+
+  Stream<Event> get onChecking => checkingEvent.forTarget(this);
+
+  Stream<Event> get onDownloading => downloadingEvent.forTarget(this);
+
+  Stream<Event> get onError => errorEvent.forTarget(this);
+
+  Stream<Event> get onNoUpdate => noUpdateEvent.forTarget(this);
+
+  Stream<Event> get onObsolete => obsoleteEvent.forTarget(this);
+
+  Stream<Event> get onProgress => progressEvent.forTarget(this);
+
+  Stream<Event> get onUpdateReady => updateReadyEvent.forTarget(this);
 }
 
 /// @docsEditable true
 class ApplicationCacheEvents extends Events {
   /// @docsEditable true
   ApplicationCacheEvents(EventTarget _ptr) : super(_ptr);
 
   /// @docsEditable true
   EventListenerList get cached => this['cached'];
 
@@ skipping 244 matching lines @@
   int size;
 }
 // Copyright (c) 2012, 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.
 
 
 /// @domName BatteryManager; @docsEditable true
 class BatteryManager extends EventTarget native "*BatteryManager" {
 
+  static const EventStreamProvider<Event> chargingChangeEvent = const EventStreamProvider<Event>('chargingchange');
+
+  static const EventStreamProvider<Event> chargingTimeChangeEvent = const EventStreamProvider<Event>('chargingtimechange');
+
+  static const EventStreamProvider<Event> dischargingTimeChangeEvent = const EventStreamProvider<Event>('dischargingtimechange');
+
+  static const EventStreamProvider<Event> levelChangeEvent = const EventStreamProvider<Event>('levelchange');
+
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   BatteryManagerEvents get on =>
     new BatteryManagerEvents(this);
 
   /// @domName BatteryManager.charging; @docsEditable true
   final bool charging;
 
   /// @domName BatteryManager.chargingTime; @docsEditable true
   final num chargingTime;
 
   /// @domName BatteryManager.dischargingTime; @docsEditable true
   final num dischargingTime;
 
   /// @domName BatteryManager.level; @docsEditable true
   final num level;
 
   /// @domName BatteryManager.addEventListener; @docsEditable true
   @JSName('addEventListener')
   void $dom_addEventListener(String type, EventListener listener, [bool useCapture]) native;
 
   /// @domName BatteryManager.dispatchEvent; @docsEditable true
   @JSName('dispatchEvent')
   bool $dom_dispatchEvent(Event event) native;
 
   /// @domName BatteryManager.removeEventListener; @docsEditable true
   @JSName('removeEventListener')
   void $dom_removeEventListener(String type, EventListener listener, [bool useCapture]) native;
+
+  Stream<Event> get onChargingChange => chargingChangeEvent.forTarget(this);
+
+  Stream<Event> get onChargingTimeChange => chargingTimeChangeEvent.forTarget(this);
+
+  Stream<Event> get onDischargingTimeChange => dischargingTimeChangeEvent.forTarget(this);
+
+  Stream<Event> get onLevelChange => levelChangeEvent.forTarget(this);
 }
 
 /// @docsEditable true
 class BatteryManagerEvents extends Events {
   /// @docsEditable true
   BatteryManagerEvents(EventTarget _ptr) : super(_ptr);
 
   /// @docsEditable true
   EventListenerList get chargingChange => this['chargingchange'];
 
@@ skipping 66 matching lines @@
 }
 
 // Copyright (c) 2012, 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.
 
 
 /// @domName HTMLBodyElement; @docsEditable true
 class BodyElement extends Element native "*HTMLBodyElement" {
 
+  static const EventStreamProvider<Event> beforeUnloadEvent = const EventStreamProvider<Event>('beforeunload');
+
+  static const EventStreamProvider<Event> blurEvent = const EventStreamProvider<Event>('blur');
+
+  static const EventStreamProvider<Event> errorEvent = const EventStreamProvider<Event>('error');
+
+  static const EventStreamProvider<Event> focusEvent = const EventStreamProvider<Event>('focus');
+
+  static const EventStreamProvider<HashChangeEvent> hashChangeEvent = const EventStreamProvider<HashChangeEvent>('hashchange');
+
+  static const EventStreamProvider<Event> loadEvent = const EventStreamProvider<Event>('load');
+
+  static const EventStreamProvider<MessageEvent> messageEvent = const EventStreamProvider<MessageEvent>('message');
+
+  static const EventStreamProvider<Event> offlineEvent = const EventStreamProvider<Event>('offline');
+
+  static const EventStreamProvider<Event> onlineEvent = const EventStreamProvider<Event>('online');
+
+  static const EventStreamProvider<PopStateEvent> popStateEvent = const EventStreamProvider<PopStateEvent>('popstate');
+
+  static const EventStreamProvider<Event> resizeEvent = const EventStreamProvider<Event>('resize');
+
+  static const EventStreamProvider<StorageEvent> storageEvent = const EventStreamProvider<StorageEvent>('storage');
+
+  static const EventStreamProvider<Event> unloadEvent = const EventStreamProvider<Event>('unload');
+
   ///@docsEditable true
   factory BodyElement() => document.$dom_createElement("body");
 
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   BodyElementEvents get on =>
     new BodyElementEvents(this);
 
   /// @domName HTMLBodyElement.vLink; @docsEditable true
   String vLink;
+
+  Stream<Event> get onBeforeUnload => beforeUnloadEvent.forTarget(this);
+
+  Stream<Event> get onBlur => blurEvent.forTarget(this);
+
+  Stream<Event> get onError => errorEvent.forTarget(this);
+
+  Stream<Event> get onFocus => focusEvent.forTarget(this);
+
+  Stream<HashChangeEvent> get onHashChange => hashChangeEvent.forTarget(this);
+
+  Stream<Event> get onLoad => loadEvent.forTarget(this);
+
+  Stream<MessageEvent> get onMessage => messageEvent.forTarget(this);
+
+  Stream<Event> get onOffline => offlineEvent.forTarget(this);
+
+  Stream<Event> get onOnline => onlineEvent.forTarget(this);
+
+  Stream<PopStateEvent> get onPopState => popStateEvent.forTarget(this);
+
+  Stream<Event> get onResize => resizeEvent.forTarget(this);
+
+  Stream<StorageEvent> get onStorage => storageEvent.forTarget(this);
+
+  Stream<Event> get onUnload => unloadEvent.forTarget(this);
 }
 
 /// @docsEditable true
 class BodyElementEvents extends ElementEvents {
   /// @docsEditable true
   BodyElementEvents(EventTarget _ptr) : super(_ptr);
 
   /// @docsEditable true
   EventListenerList get beforeUnload => this['beforeunload'];
 
@@ skipping 4813 matching lines @@
   void transaction(SqlTransactionSyncCallback callback) native;
 }
 // Copyright (c) 2012, 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.
 
 
 /// @domName DedicatedWorkerContext; @docsEditable true
 class DedicatedWorkerContext extends WorkerContext native "*DedicatedWorkerContext" {
 
+  static const EventStreamProvider<MessageEvent> messageEvent = const EventStreamProvider<MessageEvent>('message');
+
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   DedicatedWorkerContextEvents get on =>
     new DedicatedWorkerContextEvents(this);
 
   /// @domName DedicatedWorkerContext.postMessage; @docsEditable true
   void postMessage(/*any*/ message, [List messagePorts]) {
     if (?messagePorts) {
       var message_1 = convertDartToNative_SerializedScriptValue(message);
       _postMessage_1(message_1, messagePorts);
       return;
     }
     var message_2 = convertDartToNative_SerializedScriptValue(message);
     _postMessage_2(message_2);
     return;
   }
   @JSName('postMessage')
   void _postMessage_1(message, List messagePorts) native;
   @JSName('postMessage')
   void _postMessage_2(message) native;
+
+  Stream<MessageEvent> get onMessage => messageEvent.forTarget(this);
 }
 
 /// @docsEditable true
 class DedicatedWorkerContextEvents extends WorkerContextEvents {
   /// @docsEditable true
   DedicatedWorkerContextEvents(EventTarget _ptr) : super(_ptr);
 
   /// @docsEditable true
   EventListenerList get message => this['message'];
 }
@@ skipping 233 matching lines @@
  * Each web page loaded in the browser has its own [Document] object, which is
  * typically an [HtmlDocument].
  *
  * If you aren't comfortable with DOM concepts, see the Dart tutorial
  * [Target 2: Connect Dart & HTML](http://www.dartlang.org/docs/tutorials/connect-dart-html/).
  */
 class Document extends Node  native "*Document"
 {
 
 
+  static const EventStreamProvider<Event> abortEvent = const EventStreamProvider<Event>('abort');
+
+  static const EventStreamProvider<Event> beforeCopyEvent = const EventStreamProvider<Event>('beforecopy');
+
+  static const EventStreamProvider<Event> beforeCutEvent = const EventStreamProvider<Event>('beforecut');
+
+  static const EventStreamProvider<Event> beforePasteEvent = const EventStreamProvider<Event>('beforepaste');
+
+  static const EventStreamProvider<Event> blurEvent = const EventStreamProvider<Event>('blur');
+
+  static const EventStreamProvider<Event> changeEvent = const EventStreamProvider<Event>('change');
+
+  static const EventStreamProvider<MouseEvent> clickEvent = const EventStreamProvider<MouseEvent>('click');
+
+  static const EventStreamProvider<MouseEvent> contextMenuEvent = const EventStreamProvider<MouseEvent>('contextmenu');
+
+  static const EventStreamProvider<Event> copyEvent = const EventStreamProvider<Event>('copy');
+
+  static const EventStreamProvider<Event> cutEvent = const EventStreamProvider<Event>('cut');
+
+  static const EventStreamProvider<Event> doubleClickEvent = const EventStreamProvider<Event>('dblclick');
+
+  static const EventStreamProvider<MouseEvent> dragEvent = const EventStreamProvider<MouseEvent>('drag');
+
+  static const EventStreamProvider<MouseEvent> dragEndEvent = const EventStreamProvider<MouseEvent>('dragend');
+
+  static const EventStreamProvider<MouseEvent> dragEnterEvent = const EventStreamProvider<MouseEvent>('dragenter');
+
+  static const EventStreamProvider<MouseEvent> dragLeaveEvent = const EventStreamProvider<MouseEvent>('dragleave');
+
+  static const EventStreamProvider<MouseEvent> dragOverEvent = const EventStreamProvider<MouseEvent>('dragover');
+
+  static const EventStreamProvider<MouseEvent> dragStartEvent = const EventStreamProvider<MouseEvent>('dragstart');
+
+  static const EventStreamProvider<MouseEvent> dropEvent = const EventStreamProvider<MouseEvent>('drop');
+
+  static const EventStreamProvider<Event> errorEvent = const EventStreamProvider<Event>('error');
+
+  static const EventStreamProvider<Event> focusEvent = const EventStreamProvider<Event>('focus');
+
+  static const EventStreamProvider<Event> inputEvent = const EventStreamProvider<Event>('input');
+
+  static const EventStreamProvider<Event> invalidEvent = const EventStreamProvider<Event>('invalid');
+
+  static const EventStreamProvider<KeyboardEvent> keyDownEvent = const EventStreamProvider<KeyboardEvent>('keydown');
+
+  static const EventStreamProvider<KeyboardEvent> keyPressEvent = const EventStreamProvider<KeyboardEvent>('keypress');
+
+  static const EventStreamProvider<KeyboardEvent> keyUpEvent = const EventStreamProvider<KeyboardEvent>('keyup');
+
+  static const EventStreamProvider<Event> loadEvent = const EventStreamProvider<Event>('load');
+
+  static const EventStreamProvider<MouseEvent> mouseDownEvent = const EventStreamProvider<MouseEvent>('mousedown');
+
+  static const EventStreamProvider<MouseEvent> mouseMoveEvent = const EventStreamProvider<MouseEvent>('mousemove');
+
+  static const EventStreamProvider<MouseEvent> mouseOutEvent = const EventStreamProvider<MouseEvent>('mouseout');
+
+  static const EventStreamProvider<MouseEvent> mouseOverEvent = const EventStreamProvider<MouseEvent>('mouseover');
+
+  static const EventStreamProvider<MouseEvent> mouseUpEvent = const EventStreamProvider<MouseEvent>('mouseup');
+
+  static const EventStreamProvider<WheelEvent> mouseWheelEvent = const EventStreamProvider<WheelEvent>('mousewheel');
+
+  static const EventStreamProvider<Event> pasteEvent = const EventStreamProvider<Event>('paste');
+
+  static const EventStreamProvider<Event> readyStateChangeEvent = const EventStreamProvider<Event>('readystatechange');
+
+  static const EventStreamProvider<Event> resetEvent = const EventStreamProvider<Event>('reset');
+
+  static const EventStreamProvider<Event> scrollEvent = const EventStreamProvider<Event>('scroll');
+
+  static const EventStreamProvider<Event> searchEvent = const EventStreamProvider<Event>('search');
+
+  static const EventStreamProvider<Event> selectEvent = const EventStreamProvider<Event>('select');
+
+  static const EventStreamProvider<Event> selectionChangeEvent = const EventStreamProvider<Event>('selectionchange');
+
+  static const EventStreamProvider<Event> selectStartEvent = const EventStreamProvider<Event>('selectstart');
+
+  static const EventStreamProvider<Event> submitEvent = const EventStreamProvider<Event>('submit');
+
+  static const EventStreamProvider<TouchEvent> touchCancelEvent = const EventStreamProvider<TouchEvent>('touchcancel');
+
+  static const EventStreamProvider<TouchEvent> touchEndEvent = const EventStreamProvider<TouchEvent>('touchend');
+
+  static const EventStreamProvider<TouchEvent> touchMoveEvent = const EventStreamProvider<TouchEvent>('touchmove');
+
+  static const EventStreamProvider<TouchEvent> touchStartEvent = const EventStreamProvider<TouchEvent>('touchstart');
+
+  static const EventStreamProvider<Event> fullscreenChangeEvent = const EventStreamProvider<Event>('webkitfullscreenchange');
+
+  static const EventStreamProvider<Event> fullscreenErrorEvent = const EventStreamProvider<Event>('webkitfullscreenerror');
+
+  static const EventStreamProvider<Event> pointerLockChangeEvent = const EventStreamProvider<Event>('webkitpointerlockchange');
+
+  static const EventStreamProvider<Event> pointerLockErrorEvent = const EventStreamProvider<Event>('webkitpointerlockerror');
+
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   DocumentEvents get on =>
     new DocumentEvents(this);
 
   /// Moved to [HtmlDocument].
   /// @domName Document.body; @docsEditable true
   @JSName('body')
   Element $dom_body;
 
   /// @domName Document.charset; @docsEditable true
@@ skipping 196 matching lines @@
   /// Moved to [HtmlDocument].
   /// @domName Document.webkitExitFullscreen; @docsEditable true
   @JSName('webkitExitFullscreen')
   void $dom_webkitExitFullscreen() native;
 
   /// Moved to [HtmlDocument].
   /// @domName Document.webkitExitPointerLock; @docsEditable true
   @JSName('webkitExitPointerLock')
   void $dom_webkitExitPointerLock() native;
 
+  Stream<Event> get onAbort => abortEvent.forTarget(this);
+
+  Stream<Event> get onBeforeCopy => beforeCopyEvent.forTarget(this);
+
+  Stream<Event> get onBeforeCut => beforeCutEvent.forTarget(this);
+
+  Stream<Event> get onBeforePaste => beforePasteEvent.forTarget(this);
+
+  Stream<Event> get onBlur => blurEvent.forTarget(this);
+
+  Stream<Event> get onChange => changeEvent.forTarget(this);
+
+  Stream<MouseEvent> get onClick => clickEvent.forTarget(this);
+
+  Stream<MouseEvent> get onContextMenu => contextMenuEvent.forTarget(this);
+
+  Stream<Event> get onCopy => copyEvent.forTarget(this);
+
+  Stream<Event> get onCut => cutEvent.forTarget(this);
+
+  Stream<Event> get onDoubleClick => doubleClickEvent.forTarget(this);
+
+  Stream<MouseEvent> get onDrag => dragEvent.forTarget(this);
+
+  Stream<MouseEvent> get onDragEnd => dragEndEvent.forTarget(this);
+
+  Stream<MouseEvent> get onDragEnter => dragEnterEvent.forTarget(this);
+
+  Stream<MouseEvent> get onDragLeave => dragLeaveEvent.forTarget(this);
+
+  Stream<MouseEvent> get onDragOver => dragOverEvent.forTarget(this);
+
+  Stream<MouseEvent> get onDragStart => dragStartEvent.forTarget(this);
+
+  Stream<MouseEvent> get onDrop => dropEvent.forTarget(this);
+
+  Stream<Event> get onError => errorEvent.forTarget(this);
+
+  Stream<Event> get onFocus => focusEvent.forTarget(this);
+
+  Stream<Event> get onInput => inputEvent.forTarget(this);
+
+  Stream<Event> get onInvalid => invalidEvent.forTarget(this);
+
+  Stream<KeyboardEvent> get onKeyDown => keyDownEvent.forTarget(this);
+
+  Stream<KeyboardEvent> get onKeyPress => keyPressEvent.forTarget(this);
+
+  Stream<KeyboardEvent> get onKeyUp => keyUpEvent.forTarget(this);
+
+  Stream<Event> get onLoad => loadEvent.forTarget(this);
+
+  Stream<MouseEvent> get onMouseDown => mouseDownEvent.forTarget(this);
+
+  Stream<MouseEvent> get onMouseMove => mouseMoveEvent.forTarget(this);
+
+  Stream<MouseEvent> get onMouseOut => mouseOutEvent.forTarget(this);
+
+  Stream<MouseEvent> get onMouseOver => mouseOverEvent.forTarget(this);
+
+  Stream<MouseEvent> get onMouseUp => mouseUpEvent.forTarget(this);
+
+  Stream<WheelEvent> get onMouseWheel => mouseWheelEvent.forTarget(this);
+
+  Stream<Event> get onPaste => pasteEvent.forTarget(this);
+
+  Stream<Event> get onReadyStateChange => readyStateChangeEvent.forTarget(this);
+
+  Stream<Event> get onReset => resetEvent.forTarget(this);
+
+  Stream<Event> get onScroll => scrollEvent.forTarget(this);
+
+  Stream<Event> get onSearch => searchEvent.forTarget(this);
+
+  Stream<Event> get onSelect => selectEvent.forTarget(this);
+
+  Stream<Event> get onSelectionChange => selectionChangeEvent.forTarget(this);
+
+  Stream<Event> get onSelectStart => selectStartEvent.forTarget(this);
+
+  Stream<Event> get onSubmit => submitEvent.forTarget(this);
+
+  Stream<TouchEvent> get onTouchCancel => touchCancelEvent.forTarget(this);
+
+  Stream<TouchEvent> get onTouchEnd => touchEndEvent.forTarget(this);
+
+  Stream<TouchEvent> get onTouchMove => touchMoveEvent.forTarget(this);
+
+  Stream<TouchEvent> get onTouchStart => touchStartEvent.forTarget(this);
+
+  Stream<Event> get onFullscreenChange => fullscreenChangeEvent.forTarget(this);
+
+  Stream<Event> get onFullscreenError => fullscreenErrorEvent.forTarget(this);
+
+  Stream<Event> get onPointerLockChange => pointerLockChangeEvent.forTarget(this);
+
+  Stream<Event> get onPointerLockError => pointerLockErrorEvent.forTarget(this);
+
 
   /**
    * Finds the first descendant element of this document that matches the
    * specified group of selectors.
    *
    * Unless your webpage contains multiple documents, the top-level query
    * method behaves the same as this method, so you should use it instead to
    * save typing a few characters.
    *
    * [selectors] should be a string using CSS selector syntax.
@@ skipping 1990 matching lines @@
     } else if (JS('bool', '!!#.webkitMatchesSelector', this)) {
       return JS('bool', '#.webkitMatchesSelector(#)', this, selectors);
     } else if (JS('bool', '!!#.mozMatchesSelector', this)) {
       return JS('bool', '#.mozMatchesSelector(#)', this, selectors);
     } else if (JS('bool', '!!#.msMatchesSelector', this)) {
       return JS('bool', '#.msMatchesSelector(#)', this, selectors);
     }
   }
 
 
+  static const EventStreamProvider<Event> abortEvent = const EventStreamProvider<Event>('abort');
+
+  static const EventStreamProvider<Event> beforeCopyEvent = const EventStreamProvider<Event>('beforecopy');
+
+  static const EventStreamProvider<Event> beforeCutEvent = const EventStreamProvider<Event>('beforecut');
+
+  static const EventStreamProvider<Event> beforePasteEvent = const EventStreamProvider<Event>('beforepaste');
+
+  static const EventStreamProvider<Event> blurEvent = const EventStreamProvider<Event>('blur');
+
+  static const EventStreamProvider<Event> changeEvent = const EventStreamProvider<Event>('change');
+
+  static const EventStreamProvider<MouseEvent> clickEvent = const EventStreamProvider<MouseEvent>('click');
+
+  static const EventStreamProvider<MouseEvent> contextMenuEvent = const EventStreamProvider<MouseEvent>('contextmenu');
+
+  static const EventStreamProvider<Event> copyEvent = const EventStreamProvider<Event>('copy');
+
+  static const EventStreamProvider<Event> cutEvent = const EventStreamProvider<Event>('cut');
+
+  static const EventStreamProvider<Event> doubleClickEvent = const EventStreamProvider<Event>('dblclick');
+
+  static const EventStreamProvider<MouseEvent> dragEvent = const EventStreamProvider<MouseEvent>('drag');
+
+  static const EventStreamProvider<MouseEvent> dragEndEvent = const EventStreamProvider<MouseEvent>('dragend');
+
+  static const EventStreamProvider<MouseEvent> dragEnterEvent = const EventStreamProvider<MouseEvent>('dragenter');
+
+  static const EventStreamProvider<MouseEvent> dragLeaveEvent = const EventStreamProvider<MouseEvent>('dragleave');
+
+  static const EventStreamProvider<MouseEvent> dragOverEvent = const EventStreamProvider<MouseEvent>('dragover');
+
+  static const EventStreamProvider<MouseEvent> dragStartEvent = const EventStreamProvider<MouseEvent>('dragstart');
+
+  static const EventStreamProvider<MouseEvent> dropEvent = const EventStreamProvider<MouseEvent>('drop');
+
+  static const EventStreamProvider<Event> errorEvent = const EventStreamProvider<Event>('error');
+
+  static const EventStreamProvider<Event> focusEvent = const EventStreamProvider<Event>('focus');
+
+  static const EventStreamProvider<Event> inputEvent = const EventStreamProvider<Event>('input');
+
+  static const EventStreamProvider<Event> invalidEvent = const EventStreamProvider<Event>('invalid');
+
+  static const EventStreamProvider<KeyboardEvent> keyDownEvent = const EventStreamProvider<KeyboardEvent>('keydown');
+
+  static const EventStreamProvider<KeyboardEvent> keyPressEvent = const EventStreamProvider<KeyboardEvent>('keypress');
+
+  static const EventStreamProvider<KeyboardEvent> keyUpEvent = const EventStreamProvider<KeyboardEvent>('keyup');
+
+  static const EventStreamProvider<Event> loadEvent = const EventStreamProvider<Event>('load');
+
+  static const EventStreamProvider<MouseEvent> mouseDownEvent = const EventStreamProvider<MouseEvent>('mousedown');
+
+  static const EventStreamProvider<MouseEvent> mouseMoveEvent = const EventStreamProvider<MouseEvent>('mousemove');
+
+  static const EventStreamProvider<MouseEvent> mouseOutEvent = const EventStreamProvider<MouseEvent>('mouseout');
+
+  static const EventStreamProvider<MouseEvent> mouseOverEvent = const EventStreamProvider<MouseEvent>('mouseover');
+
+  static const EventStreamProvider<MouseEvent> mouseUpEvent = const EventStreamProvider<MouseEvent>('mouseup');
+
+  static const EventStreamProvider<Event> pasteEvent = const EventStreamProvider<Event>('paste');
+
+  static const EventStreamProvider<Event> resetEvent = const EventStreamProvider<Event>('reset');
+
+  static const EventStreamProvider<Event> scrollEvent = const EventStreamProvider<Event>('scroll');
+
+  static const EventStreamProvider<Event> searchEvent = const EventStreamProvider<Event>('search');
+
+  static const EventStreamProvider<Event> selectEvent = const EventStreamProvider<Event>('select');
+
+  static const EventStreamProvider<Event> selectStartEvent = const EventStreamProvider<Event>('selectstart');
+
+  static const EventStreamProvider<Event> submitEvent = const EventStreamProvider<Event>('submit');
+
+  static const EventStreamProvider<TouchEvent> touchCancelEvent = const EventStreamProvider<TouchEvent>('touchcancel');
+
+  static const EventStreamProvider<TouchEvent> touchEndEvent = const EventStreamProvider<TouchEvent>('touchend');
+
+  static const EventStreamProvider<TouchEvent> touchEnterEvent = const EventStreamProvider<TouchEvent>('touchenter');
+
+  static const EventStreamProvider<TouchEvent> touchLeaveEvent = const EventStreamProvider<TouchEvent>('touchleave');
+
+  static const EventStreamProvider<TouchEvent> touchMoveEvent = const EventStreamProvider<TouchEvent>('touchmove');
+
+  static const EventStreamProvider<TouchEvent> touchStartEvent = const EventStreamProvider<TouchEvent>('touchstart');
+
+  static const EventStreamProvider<TransitionEvent> transitionEndEvent = const EventStreamProvider<TransitionEvent>('webkitTransitionEnd');
+
+  static const EventStreamProvider<Event> fullscreenChangeEvent = const EventStreamProvider<Event>('webkitfullscreenchange');
+
+  static const EventStreamProvider<Event> fullscreenErrorEvent = const EventStreamProvider<Event>('webkitfullscreenerror');
+
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   ElementEvents get on =>
     new ElementEvents(this);
 
   /// @domName HTMLElement.children; @docsEditable true
   @JSName('children')
   final HtmlCollection $dom_children;
 
   /// @domName HTMLElement.contentEditable; @docsEditable true
   String contentEditable;
@@ skipping 201 matching lines @@
 
   /// @domName Element.webkitRequestFullScreen; @docsEditable true
   void webkitRequestFullScreen(int flags) native;
 
   /// @domName Element.webkitRequestFullscreen; @docsEditable true
   void webkitRequestFullscreen() native;
 
   /// @domName Element.webkitRequestPointerLock; @docsEditable true
   void webkitRequestPointerLock() native;
 
+  Stream<Event> get onAbort => abortEvent.forTarget(this);
+
+  Stream<Event> get onBeforeCopy => beforeCopyEvent.forTarget(this);
+
+  Stream<Event> get onBeforeCut => beforeCutEvent.forTarget(this);
+
+  Stream<Event> get onBeforePaste => beforePasteEvent.forTarget(this);
+
+  Stream<Event> get onBlur => blurEvent.forTarget(this);
+
+  Stream<Event> get onChange => changeEvent.forTarget(this);
+
+  Stream<MouseEvent> get onClick => clickEvent.forTarget(this);
+
+  Stream<MouseEvent> get onContextMenu => contextMenuEvent.forTarget(this);
+
+  Stream<Event> get onCopy => copyEvent.forTarget(this);
+
+  Stream<Event> get onCut => cutEvent.forTarget(this);
+
+  Stream<Event> get onDoubleClick => doubleClickEvent.forTarget(this);
+
+  Stream<MouseEvent> get onDrag => dragEvent.forTarget(this);
+
+  Stream<MouseEvent> get onDragEnd => dragEndEvent.forTarget(this);
+
+  Stream<MouseEvent> get onDragEnter => dragEnterEvent.forTarget(this);
+
+  Stream<MouseEvent> get onDragLeave => dragLeaveEvent.forTarget(this);
+
+  Stream<MouseEvent> get onDragOver => dragOverEvent.forTarget(this);
+
+  Stream<MouseEvent> get onDragStart => dragStartEvent.forTarget(this);
+
+  Stream<MouseEvent> get onDrop => dropEvent.forTarget(this);
+
+  Stream<Event> get onError => errorEvent.forTarget(this);
+
+  Stream<Event> get onFocus => focusEvent.forTarget(this);
+
+  Stream<Event> get onInput => inputEvent.forTarget(this);
+
+  Stream<Event> get onInvalid => invalidEvent.forTarget(this);
+
+  Stream<KeyboardEvent> get onKeyDown => keyDownEvent.forTarget(this);
+
+  Stream<KeyboardEvent> get onKeyPress => keyPressEvent.forTarget(this);
+
+  Stream<KeyboardEvent> get onKeyUp => keyUpEvent.forTarget(this);
+
+  Stream<Event> get onLoad => loadEvent.forTarget(this);
+
+  Stream<MouseEvent> get onMouseDown => mouseDownEvent.forTarget(this);
+
+  Stream<MouseEvent> get onMouseMove => mouseMoveEvent.forTarget(this);
+
+  Stream<MouseEvent> get onMouseOut => mouseOutEvent.forTarget(this);
+
+  Stream<MouseEvent> get onMouseOver => mouseOverEvent.forTarget(this);
+
+  Stream<MouseEvent> get onMouseUp => mouseUpEvent.forTarget(this);
+
+  Stream<Event> get onPaste => pasteEvent.forTarget(this);
+
+  Stream<Event> get onReset => resetEvent.forTarget(this);
+
+  Stream<Event> get onScroll => scrollEvent.forTarget(this);
+
+  Stream<Event> get onSearch => searchEvent.forTarget(this);
+
+  Stream<Event> get onSelect => selectEvent.forTarget(this);
+
+  Stream<Event> get onSelectStart => selectStartEvent.forTarget(this);
+
+  Stream<Event> get onSubmit => submitEvent.forTarget(this);
+
+  Stream<TouchEvent> get onTouchCancel => touchCancelEvent.forTarget(this);
+
+  Stream<TouchEvent> get onTouchEnd => touchEndEvent.forTarget(this);
+
+  Stream<TouchEvent> get onTouchEnter => touchEnterEvent.forTarget(this);
+
+  Stream<TouchEvent> get onTouchLeave => touchLeaveEvent.forTarget(this);
+
+  Stream<TouchEvent> get onTouchMove => touchMoveEvent.forTarget(this);
+
+  Stream<TouchEvent> get onTouchStart => touchStartEvent.forTarget(this);
+
+  Stream<TransitionEvent> get onTransitionEnd => transitionEndEvent.forTarget(this);
+
+  Stream<Event> get onFullscreenChange => fullscreenChangeEvent.forTarget(this);
+
+  Stream<Event> get onFullscreenError => fullscreenErrorEvent.forTarget(this);
+
 }
 
 final _START_TAG_REGEXP = new RegExp('<(\\w+)');
 class _ElementFactoryProvider {
   static final _CUSTOM_PARENT_TAG_MAP = const {
     'body' : 'html',
     'head' : 'html',
     'caption' : 'table',
     'td': 'tr',
     'colgroup': 'table',
@@ skipping 533 matching lines @@
   String toString() native;
 }
 // Copyright (c) 2012, 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.
 
 
 /// @domName EventSource; @docsEditable true
 class EventSource extends EventTarget native "*EventSource" {
 
+  static const EventStreamProvider<Event> errorEvent = const EventStreamProvider<Event>('error');
+
+  static const EventStreamProvider<MessageEvent> messageEvent = const EventStreamProvider<MessageEvent>('message');
+
+  static const EventStreamProvider<Event> openEvent = const EventStreamProvider<Event>('open');
+
   ///@docsEditable true
   factory EventSource(String scriptUrl) => EventSource._create(scriptUrl);
   static EventSource _create(String scriptUrl) => JS('EventSource', 'new EventSource(#)', scriptUrl);
 
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   EventSourceEvents get on =>
     new EventSourceEvents(this);
 
   static const int CLOSED = 2;
 
@@ skipping 14 matching lines @@
   /// @domName EventSource.close; @docsEditable true
   void close() native;
 
   /// @domName EventSource.dispatchEvent; @docsEditable true
   @JSName('dispatchEvent')
   bool $dom_dispatchEvent(Event evt) native;
 
   /// @domName EventSource.removeEventListener; @docsEditable true
   @JSName('removeEventListener')
   void $dom_removeEventListener(String type, EventListener listener, [bool useCapture]) native;
+
+  Stream<Event> get onError => errorEvent.forTarget(this);
+
+  Stream<MessageEvent> get onMessage => messageEvent.forTarget(this);
+
+  Stream<Event> get onOpen => openEvent.forTarget(this);
 }
 
 /// @docsEditable true
 class EventSourceEvents extends Events {
   /// @docsEditable true
   EventSourceEvents(EventTarget _ptr) : super(_ptr);
 
   /// @docsEditable true
   EventListenerList get error => this['error'];
 
@@ skipping 441 matching lines @@
   File item(int index) native;
 }
 // Copyright (c) 2012, 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.
 
 
 /// @domName FileReader; @docsEditable true
 class FileReader extends EventTarget native "*FileReader" {
 
+  static const EventStreamProvider<ProgressEvent> abortEvent = const EventStreamProvider<ProgressEvent>('abort');
+
+  static const EventStreamProvider<Event> errorEvent = const EventStreamProvider<Event>('error');
+
+  static const EventStreamProvider<ProgressEvent> loadEvent = const EventStreamProvider<ProgressEvent>('load');
+
+  static const EventStreamProvider<ProgressEvent> loadEndEvent = const EventStreamProvider<ProgressEvent>('loadend');
+
+  static const EventStreamProvider<ProgressEvent> loadStartEvent = const EventStreamProvider<ProgressEvent>('loadstart');
+
+  static const EventStreamProvider<ProgressEvent> progressEvent = const EventStreamProvider<ProgressEvent>('progress');
+
   ///@docsEditable true
   factory FileReader() => FileReader._create();
   static FileReader _create() => JS('FileReader', 'new FileReader()');
 
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   FileReaderEvents get on =>
     new FileReaderEvents(this);
 
   static const int DONE = 2;
 
@@ skipping 31 matching lines @@
   /// @domName FileReader.readAsDataURL; @docsEditable true
   @JSName('readAsDataURL')
   void readAsDataUrl(Blob blob) native;
 
   /// @domName FileReader.readAsText; @docsEditable true
   void readAsText(Blob blob, [String encoding]) native;
 
   /// @domName FileReader.removeEventListener; @docsEditable true
   @JSName('removeEventListener')
   void $dom_removeEventListener(String type, EventListener listener, [bool useCapture]) native;
+
+  Stream<ProgressEvent> get onAbort => abortEvent.forTarget(this);
+
+  Stream<Event> get onError => errorEvent.forTarget(this);
+
+  Stream<ProgressEvent> get onLoad => loadEvent.forTarget(this);
+
+  Stream<ProgressEvent> get onLoadEnd => loadEndEvent.forTarget(this);
+
+  Stream<ProgressEvent> get onLoadStart => loadStartEvent.forTarget(this);
+
+  Stream<ProgressEvent> get onProgress => progressEvent.forTarget(this);
 }
 
 /// @docsEditable true
 class FileReaderEvents extends Events {
   /// @docsEditable true
   FileReaderEvents(EventTarget _ptr) : super(_ptr);
 
   /// @docsEditable true
   EventListenerList get abort => this['abort'];
 
@@ skipping 74 matching lines @@
   final DirectoryEntrySync root;
 }
 // Copyright (c) 2012, 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.
 
 
 /// @domName FileWriter; @docsEditable true
 class FileWriter extends EventTarget native "*FileWriter" {
 
+  static const EventStreamProvider<ProgressEvent> abortEvent = const EventStreamProvider<ProgressEvent>('abort');
+
+  static const EventStreamProvider<Event> errorEvent = const EventStreamProvider<Event>('error');
+
+  static const EventStreamProvider<ProgressEvent> progressEvent = const EventStreamProvider<ProgressEvent>('progress');
+
+  static const EventStreamProvider<ProgressEvent> writeEvent = const EventStreamProvider<ProgressEvent>('write');
+
+  static const EventStreamProvider<ProgressEvent> writeEndEvent = const EventStreamProvider<ProgressEvent>('writeend');
+
+  static const EventStreamProvider<ProgressEvent> writeStartEvent = const EventStreamProvider<ProgressEvent>('writestart');
+
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   FileWriterEvents get on =>
     new FileWriterEvents(this);
 
   static const int DONE = 2;
 
   static const int INIT = 0;
 
   static const int WRITING = 1;
 
@@ skipping 25 matching lines @@
   void $dom_removeEventListener(String type, EventListener listener, [bool useCapture]) native;
 
   /// @domName FileWriter.seek; @docsEditable true
   void seek(int position) native;
 
   /// @domName FileWriter.truncate; @docsEditable true
   void truncate(int size) native;
 
   /// @domName FileWriter.write; @docsEditable true
   void write(Blob data) native;
+
+  Stream<ProgressEvent> get onAbort => abortEvent.forTarget(this);
+
+  Stream<Event> get onError => errorEvent.forTarget(this);
+
+  Stream<ProgressEvent> get onProgress => progressEvent.forTarget(this);
+
+  Stream<ProgressEvent> get onWrite => writeEvent.forTarget(this);
+
+  Stream<ProgressEvent> get onWriteEnd => writeEndEvent.forTarget(this);
+
+  Stream<ProgressEvent> get onWriteStart => writeStartEvent.forTarget(this);
 }
 
 /// @docsEditable true
 class FileWriterEvents extends Events {
   /// @docsEditable true
   FileWriterEvents(EventTarget _ptr) : super(_ptr);
 
   /// @docsEditable true
   EventListenerList get abort => this['abort'];
 
@@ skipping 525 matching lines @@
   final int width;
 }
 // Copyright (c) 2012, 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.
 
 
 /// @domName HTMLFrameSetElement; @docsEditable true
 class FrameSetElement extends Element native "*HTMLFrameSetElement" {
 
+  static const EventStreamProvider<Event> beforeUnloadEvent = const EventStreamProvider<Event>('beforeunload');
+
+  static const EventStreamProvider<Event> blurEvent = const EventStreamProvider<Event>('blur');
+
+  static const EventStreamProvider<Event> errorEvent = const EventStreamProvider<Event>('error');
+
+  static const EventStreamProvider<Event> focusEvent = const EventStreamProvider<Event>('focus');
+
+  static const EventStreamProvider<HashChangeEvent> hashChangeEvent = const EventStreamProvider<HashChangeEvent>('hashchange');
+
+  static const EventStreamProvider<Event> loadEvent = const EventStreamProvider<Event>('load');
+
+  static const EventStreamProvider<MessageEvent> messageEvent = const EventStreamProvider<MessageEvent>('message');
+
+  static const EventStreamProvider<Event> offlineEvent = const EventStreamProvider<Event>('offline');
+
+  static const EventStreamProvider<Event> onlineEvent = const EventStreamProvider<Event>('online');
+
+  static const EventStreamProvider<PopStateEvent> popStateEvent = const EventStreamProvider<PopStateEvent>('popstate');
+
+  static const EventStreamProvider<Event> resizeEvent = const EventStreamProvider<Event>('resize');
+
+  static const EventStreamProvider<StorageEvent> storageEvent = const EventStreamProvider<StorageEvent>('storage');
+
+  static const EventStreamProvider<Event> unloadEvent = const EventStreamProvider<Event>('unload');
+
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   FrameSetElementEvents get on =>
     new FrameSetElementEvents(this);
 
   /// @domName HTMLFrameSetElement.cols; @docsEditable true
   String cols;
 
   /// @domName HTMLFrameSetElement.rows; @docsEditable true
   String rows;
+
+  Stream<Event> get onBeforeUnload => beforeUnloadEvent.forTarget(this);
+
+  Stream<Event> get onBlur => blurEvent.forTarget(this);
+
+  Stream<Event> get onError => errorEvent.forTarget(this);
+
+  Stream<Event> get onFocus => focusEvent.forTarget(this);
+
+  Stream<HashChangeEvent> get onHashChange => hashChangeEvent.forTarget(this);
+
+  Stream<Event> get onLoad => loadEvent.forTarget(this);
+
+  Stream<MessageEvent> get onMessage => messageEvent.forTarget(this);
+
+  Stream<Event> get onOffline => offlineEvent.forTarget(this);
+
+  Stream<Event> get onOnline => onlineEvent.forTarget(this);
+
+  Stream<PopStateEvent> get onPopState => popStateEvent.forTarget(this);
+
+  Stream<Event> get onResize => resizeEvent.forTarget(this);
+
+  Stream<StorageEvent> get onStorage => storageEvent.forTarget(this);
+
+  Stream<Event> get onUnload => unloadEvent.forTarget(this);
 }
 
 /// @docsEditable true
 class FrameSetElementEvents extends ElementEvents {
   /// @docsEditable true
   FrameSetElementEvents(EventTarget _ptr) : super(_ptr);
 
   /// @docsEditable true
   EventListenerList get beforeUnload => this['beforeunload'];
 
@@ skipping 732 matching lines @@
    * * The `Access-Control-Allow-Credentials` header of `url` must be set to true.
    * * If `Access-Control-Expose-Headers` has not been set to true, only a subset of all the response headers will be returned when calling [getAllRequestHeaders].
    *
    * See also: [authorization headers](http://en.wikipedia.org/wiki/Basic_access_authentication).
    */
   factory HttpRequest.getWithCredentials(String url,
       onComplete(HttpRequest request)) =>
       _HttpRequestUtils.get(url, onComplete, true);
 
 
+  static const EventStreamProvider<ProgressEvent> abortEvent = const EventStreamProvider<ProgressEvent>('abort');
+
+  static const EventStreamProvider<ProgressEvent> errorEvent = const EventStreamProvider<ProgressEvent>('error');
+
+  static const EventStreamProvider<ProgressEvent> loadEvent = const EventStreamProvider<ProgressEvent>('load');
+
+  static const EventStreamProvider<ProgressEvent> loadEndEvent = const EventStreamProvider<ProgressEvent>('loadend');
+
+  static const EventStreamProvider<ProgressEvent> loadStartEvent = const EventStreamProvider<ProgressEvent>('loadstart');
+
+  static const EventStreamProvider<ProgressEvent> progressEvent = const EventStreamProvider<ProgressEvent>('progress');
+
+  static const EventStreamProvider<ProgressEvent> readyStateChangeEvent = const EventStreamProvider<ProgressEvent>('readystatechange');
+
   ///@docsEditable true
   factory HttpRequest() => HttpRequest._create();
   static HttpRequest _create() => JS('HttpRequest', 'new XMLHttpRequest()');
 
   /**
    * Get the set of [HttpRequestEvents] that this request can respond to.
    * Usually used when adding an EventListener, such as in
    * `document.window.on.keyDown.add((e) => print('keydown happened'))`.
    */
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
@@ skipping 190 matching lines @@
    * [send() docs](https://developer.mozilla.org/en-US/docs/DOM/XMLHttpRequest#send())
    * from MDN.
    */
   /// @domName XMLHttpRequest.send; @docsEditable true
   void send([data]) native;
 
   /** Sets HTTP `header` to `value`. */
   /// @domName XMLHttpRequest.setRequestHeader; @docsEditable true
   void setRequestHeader(String header, String value) native;
 
+  Stream<ProgressEvent> get onAbort => abortEvent.forTarget(this);
+
+  Stream<ProgressEvent> get onError => errorEvent.forTarget(this);
+
+  Stream<ProgressEvent> get onLoad => loadEvent.forTarget(this);
+
+  Stream<ProgressEvent> get onLoadEnd => loadEndEvent.forTarget(this);
+
+  Stream<ProgressEvent> get onLoadStart => loadStartEvent.forTarget(this);
+
+  Stream<ProgressEvent> get onProgress => progressEvent.forTarget(this);
+
+  Stream<ProgressEvent> get onReadyStateChange => readyStateChangeEvent.forTarget(this);
+
 }
 
 /**
  * A class that supports listening for and dispatching events that can fire when
  * making an HTTP request.
  *
  * Here's an example of adding an event handler that executes once an HTTP
  * request has fully loaded:
  *
  *     httpRequest.on.loadEnd.add((e) => myCustomLoadEndHandler(e));
@@ skipping 98 matching lines @@
   final int totalSize;
 }
 // Copyright (c) 2012, 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.
 
 
 /// @domName XMLHttpRequestUpload; @docsEditable true
 class HttpRequestUpload extends EventTarget native "*XMLHttpRequestUpload" {
 
+  static const EventStreamProvider<ProgressEvent> abortEvent = const EventStreamProvider<ProgressEvent>('abort');
+
+  static const EventStreamProvider<ProgressEvent> errorEvent = const EventStreamProvider<ProgressEvent>('error');
+
+  static const EventStreamProvider<ProgressEvent> loadEvent = const EventStreamProvider<ProgressEvent>('load');
+
+  static const EventStreamProvider<ProgressEvent> loadEndEvent = const EventStreamProvider<ProgressEvent>('loadend');
+
+  static const EventStreamProvider<ProgressEvent> loadStartEvent = const EventStreamProvider<ProgressEvent>('loadstart');
+
+  static const EventStreamProvider<ProgressEvent> progressEvent = const EventStreamProvider<ProgressEvent>('progress');
+
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   HttpRequestUploadEvents get on =>
     new HttpRequestUploadEvents(this);
 
   /// @domName XMLHttpRequestUpload.addEventListener; @docsEditable true
   @JSName('addEventListener')
   void $dom_addEventListener(String type, EventListener listener, [bool useCapture]) native;
 
   /// @domName XMLHttpRequestUpload.dispatchEvent; @docsEditable true
   @JSName('dispatchEvent')
   bool $dom_dispatchEvent(Event evt) native;
 
   /// @domName XMLHttpRequestUpload.removeEventListener; @docsEditable true
   @JSName('removeEventListener')
   void $dom_removeEventListener(String type, EventListener listener, [bool useCapture]) native;
+
+  Stream<ProgressEvent> get onAbort => abortEvent.forTarget(this);
+
+  Stream<ProgressEvent> get onError => errorEvent.forTarget(this);
+
+  Stream<ProgressEvent> get onLoad => loadEvent.forTarget(this);
+
+  Stream<ProgressEvent> get onLoadEnd => loadEndEvent.forTarget(this);
+
+  Stream<ProgressEvent> get onLoadStart => loadStartEvent.forTarget(this);
+
+  Stream<ProgressEvent> get onProgress => progressEvent.forTarget(this);
 }
 
 /// @docsEditable true
 class HttpRequestUploadEvents extends Events {
   /// @docsEditable true
   HttpRequestUploadEvents(EventTarget _ptr) : super(_ptr);
 
   /// @docsEditable true
   EventListenerList get abort => this['abort'];
 
@@ skipping 159 matching lines @@
     var e = document.$dom_createElement("input");
     if (type != null) {
       try {
         // IE throws an exception for unknown types.
         e.type = type;
       } catch(_) {}
     }
     return e;
   }
 
+  static const EventStreamProvider<Event> speechChangeEvent = const EventStreamProvider<Event>('webkitSpeechChange');
+
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   InputElementEvents get on =>
     new InputElementEvents(this);
 
   /// @domName HTMLInputElement.accept; @docsEditable true
   String accept;
 
   /// @domName HTMLInputElement.alt; @docsEditable true
   String alt;
 
@@ skipping 155 matching lines @@
 
   /// @domName HTMLInputElement.setSelectionRange; @docsEditable true
   void setSelectionRange(int start, int end, [String direction]) native;
 
   /// @domName HTMLInputElement.stepDown; @docsEditable true
   void stepDown([int n]) native;
 
   /// @domName HTMLInputElement.stepUp; @docsEditable true
   void stepUp([int n]) native;
 
+  Stream<Event> get onSpeechChange => speechChangeEvent.forTarget(this);
+
 }
 
 
 // Interfaces representing the InputElement APIs which are supported
 // for the various types of InputElement.
 // From http://dev.w3.org/html5/spec/the-input-element.html#the-input-element.
 
 /**
  * Exposes the functionality common between all InputElement types.
  */
@@ skipping 1557 matching lines @@
   void unpause() native;
 }
 // Copyright (c) 2012, 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.
 
 
 /// @domName HTMLMediaElement; @docsEditable true
 class MediaElement extends Element native "*HTMLMediaElement" {
 
+  static const EventStreamProvider<Event> canPlayEvent = const EventStreamProvider<Event>('canplay');
+
+  static const EventStreamProvider<Event> canPlayThroughEvent = const EventStreamProvider<Event>('canplaythrough');
+
+  static const EventStreamProvider<Event> durationChangeEvent = const EventStreamProvider<Event>('durationchange');
+
+  static const EventStreamProvider<Event> emptiedEvent = const EventStreamProvider<Event>('emptied');
+
+  static const EventStreamProvider<Event> endedEvent = const EventStreamProvider<Event>('ended');
+
+  static const EventStreamProvider<Event> loadedDataEvent = const EventStreamProvider<Event>('loadeddata');
+
+  static const EventStreamProvider<Event> loadedMetadataEvent = const EventStreamProvider<Event>('loadedmetadata');
+
+  static const EventStreamProvider<Event> loadStartEvent = const EventStreamProvider<Event>('loadstart');
+
+  static const EventStreamProvider<Event> pauseEvent = const EventStreamProvider<Event>('pause');
+
+  static const EventStreamProvider<Event> playEvent = const EventStreamProvider<Event>('play');
+
+  static const EventStreamProvider<Event> playingEvent = const EventStreamProvider<Event>('playing');
+
+  static const EventStreamProvider<Event> progressEvent = const EventStreamProvider<Event>('progress');
+
+  static const EventStreamProvider<Event> rateChangeEvent = const EventStreamProvider<Event>('ratechange');
+
+  static const EventStreamProvider<Event> seekedEvent = const EventStreamProvider<Event>('seeked');
+
+  static const EventStreamProvider<Event> seekingEvent = const EventStreamProvider<Event>('seeking');
+
+  static const EventStreamProvider<Event> showEvent = const EventStreamProvider<Event>('show');
+
+  static const EventStreamProvider<Event> stalledEvent = const EventStreamProvider<Event>('stalled');
+
+  static const EventStreamProvider<Event> suspendEvent = const EventStreamProvider<Event>('suspend');
+
+  static const EventStreamProvider<Event> timeUpdateEvent = const EventStreamProvider<Event>('timeupdate');
+
+  static const EventStreamProvider<Event> volumeChangeEvent = const EventStreamProvider<Event>('volumechange');
+
+  static const EventStreamProvider<Event> waitingEvent = const EventStreamProvider<Event>('waiting');
+
+  static const EventStreamProvider<MediaKeyEvent> keyAddedEvent = const EventStreamProvider<MediaKeyEvent>('webkitkeyadded');
+
+  static const EventStreamProvider<MediaKeyEvent> keyErrorEvent = const EventStreamProvider<MediaKeyEvent>('webkitkeyerror');
+
+  static const EventStreamProvider<MediaKeyEvent> keyMessageEvent = const EventStreamProvider<MediaKeyEvent>('webkitkeymessage');
+
+  static const EventStreamProvider<MediaKeyEvent> needKeyEvent = const EventStreamProvider<MediaKeyEvent>('webkitneedkey');
+
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   MediaElementEvents get on =>
     new MediaElementEvents(this);
 
   static const int HAVE_CURRENT_DATA = 2;
 
   static const int HAVE_ENOUGH_DATA = 4;
 
   static const int HAVE_FUTURE_DATA = 3;
 
@@ skipping 121 matching lines @@
   void play() native;
 
   /// @domName HTMLMediaElement.webkitAddKey; @docsEditable true
   void webkitAddKey(String keySystem, Uint8Array key, [Uint8Array initData, String sessionId]) native;
 
   /// @domName HTMLMediaElement.webkitCancelKeyRequest; @docsEditable true
   void webkitCancelKeyRequest(String keySystem, String sessionId) native;
 
   /// @domName HTMLMediaElement.webkitGenerateKeyRequest; @docsEditable true
   void webkitGenerateKeyRequest(String keySystem, [Uint8Array initData]) native;
+
+  Stream<Event> get onCanPlay => canPlayEvent.forTarget(this);
+
+  Stream<Event> get onCanPlayThrough => canPlayThroughEvent.forTarget(this);
+
+  Stream<Event> get onDurationChange => durationChangeEvent.forTarget(this);
+
+  Stream<Event> get onEmptied => emptiedEvent.forTarget(this);
+
+  Stream<Event> get onEnded => endedEvent.forTarget(this);
+
+  Stream<Event> get onLoadedData => loadedDataEvent.forTarget(this);
+
+  Stream<Event> get onLoadedMetadata => loadedMetadataEvent.forTarget(this);
+
+  Stream<Event> get onLoadStart => loadStartEvent.forTarget(this);
+
+  Stream<Event> get onPause => pauseEvent.forTarget(this);
+
+  Stream<Event> get onPlay => playEvent.forTarget(this);
+
+  Stream<Event> get onPlaying => playingEvent.forTarget(this);
+
+  Stream<Event> get onProgress => progressEvent.forTarget(this);
+
+  Stream<Event> get onRateChange => rateChangeEvent.forTarget(this);
+
+  Stream<Event> get onSeeked => seekedEvent.forTarget(this);
+
+  Stream<Event> get onSeeking => seekingEvent.forTarget(this);
+
+  Stream<Event> get onShow => showEvent.forTarget(this);
+
+  Stream<Event> get onStalled => stalledEvent.forTarget(this);
+
+  Stream<Event> get onSuspend => suspendEvent.forTarget(this);
+
+  Stream<Event> get onTimeUpdate => timeUpdateEvent.forTarget(this);
+
+  Stream<Event> get onVolumeChange => volumeChangeEvent.forTarget(this);
+
+  Stream<Event> get onWaiting => waitingEvent.forTarget(this);
+
+  Stream<MediaKeyEvent> get onKeyAdded => keyAddedEvent.forTarget(this);
+
+  Stream<MediaKeyEvent> get onKeyError => keyErrorEvent.forTarget(this);
+
+  Stream<MediaKeyEvent> get onKeyMessage => keyMessageEvent.forTarget(this);
+
+  Stream<MediaKeyEvent> get onNeedKey => needKeyEvent.forTarget(this);
 }
 
 /// @docsEditable true
 class MediaElementEvents extends ElementEvents {
   /// @docsEditable true
   MediaElementEvents(EventTarget _ptr) : super(_ptr);
 
   /// @docsEditable true
   EventListenerList get canPlay => this['canplay'];
 
@@ skipping 243 matching lines @@
   void removeSourceBuffer(SourceBuffer buffer) native;
 }
 // Copyright (c) 2012, 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.
 
 
 /// @domName MediaStream; @docsEditable true
 class MediaStream extends EventTarget native "*MediaStream" {
 
+  static const EventStreamProvider<Event> endedEvent = const EventStreamProvider<Event>('ended');
+
   ///@docsEditable true
   factory MediaStream(MediaStreamTrackList audioTracks, MediaStreamTrackList videoTracks) => MediaStream._create(audioTracks, videoTracks);
   static MediaStream _create(MediaStreamTrackList audioTracks, MediaStreamTrackList videoTracks) => JS('MediaStream', 'new MediaStream(#,#)', audioTracks, videoTracks);
 
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   MediaStreamEvents get on =>
     new MediaStreamEvents(this);
 
   static const int ENDED = 2;
 
@@ skipping 15 matching lines @@
   @JSName('addEventListener')
   void $dom_addEventListener(String type, EventListener listener, [bool useCapture]) native;
 
   /// @domName MediaStream.dispatchEvent; @docsEditable true
   @JSName('dispatchEvent')
   bool $dom_dispatchEvent(Event event) native;
 
   /// @domName MediaStream.removeEventListener; @docsEditable true
   @JSName('removeEventListener')
   void $dom_removeEventListener(String type, EventListener listener, [bool useCapture]) native;
+
+  Stream<Event> get onEnded => endedEvent.forTarget(this);
 }
 
 /// @docsEditable true
 class MediaStreamEvents extends Events {
   /// @docsEditable true
   MediaStreamEvents(EventTarget _ptr) : super(_ptr);
 
   /// @docsEditable true
   EventListenerList get ended => this['ended'];
 }
 // Copyright (c) 2012, 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.
 
 
 /// @domName MediaStreamEvent; @docsEditable true
 class MediaStreamEvent extends Event native "*MediaStreamEvent" {
 
   /// @domName MediaStreamEvent.stream; @docsEditable true
   final MediaStream stream;
 }
 // Copyright (c) 2012, 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.
 
 
 /// @domName MediaStreamTrack; @docsEditable true
 class MediaStreamTrack extends EventTarget native "*MediaStreamTrack" {
 
+  static const EventStreamProvider<Event> endedEvent = const EventStreamProvider<Event>('ended');
+
+  static const EventStreamProvider<Event> muteEvent = const EventStreamProvider<Event>('mute');
+
+  static const EventStreamProvider<Event> unmuteEvent = const EventStreamProvider<Event>('unmute');
+
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   MediaStreamTrackEvents get on =>
     new MediaStreamTrackEvents(this);
 
   static const int ENDED = 2;
 
   static const int LIVE = 0;
 
   static const int MUTED = 1;
 
@@ skipping 13 matching lines @@
   @JSName('addEventListener')
   void $dom_addEventListener(String type, EventListener listener, [bool useCapture]) native;
 
   /// @domName MediaStreamTrack.dispatchEvent; @docsEditable true
   @JSName('dispatchEvent')
   bool $dom_dispatchEvent(Event event) native;
 
   /// @domName MediaStreamTrack.removeEventListener; @docsEditable true
   @JSName('removeEventListener')
   void $dom_removeEventListener(String type, EventListener listener, [bool useCapture]) native;
+
+  Stream<Event> get onEnded => endedEvent.forTarget(this);
+
+  Stream<Event> get onMute => muteEvent.forTarget(this);
+
+  Stream<Event> get onUnmute => unmuteEvent.forTarget(this);
 }
 
 /// @docsEditable true
 class MediaStreamTrackEvents extends Events {
   /// @docsEditable true
   MediaStreamTrackEvents(EventTarget _ptr) : super(_ptr);
 
   /// @docsEditable true
   EventListenerList get ended => this['ended'];
 
@@ skipping 15 matching lines @@
   final MediaStreamTrack track;
 }
 // Copyright (c) 2012, 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.
 
 
 /// @domName MediaStreamTrackList; @docsEditable true
 class MediaStreamTrackList extends EventTarget native "*MediaStreamTrackList" {
 
+  static const EventStreamProvider<MediaStreamTrackEvent> addTrackEvent = const EventStreamProvider<MediaStreamTrackEvent>('addtrack');
+
+  static const EventStreamProvider<MediaStreamTrackEvent> removeTrackEvent = const EventStreamProvider<MediaStreamTrackEvent>('removetrack');
+
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   MediaStreamTrackListEvents get on =>
     new MediaStreamTrackListEvents(this);
 
   /// @domName MediaStreamTrackList.length; @docsEditable true
   final int length;
 
   /// @domName MediaStreamTrackList.add; @docsEditable true
   void add(MediaStreamTrack track) native;
 
   /// @domName MediaStreamTrackList.addEventListener; @docsEditable true
   @JSName('addEventListener')
   void $dom_addEventListener(String type, EventListener listener, [bool useCapture]) native;
 
   /// @domName MediaStreamTrackList.dispatchEvent; @docsEditable true
   @JSName('dispatchEvent')
   bool $dom_dispatchEvent(Event event) native;
 
   /// @domName MediaStreamTrackList.item; @docsEditable true
   MediaStreamTrack item(int index) native;
 
   /// @domName MediaStreamTrackList.remove; @docsEditable true
   void remove(MediaStreamTrack track) native;
 
   /// @domName MediaStreamTrackList.removeEventListener; @docsEditable true
   @JSName('removeEventListener')
   void $dom_removeEventListener(String type, EventListener listener, [bool useCapture]) native;
+
+  Stream<MediaStreamTrackEvent> get onAddTrack => addTrackEvent.forTarget(this);
+
+  Stream<MediaStreamTrackEvent> get onRemoveTrack => removeTrackEvent.forTarget(this);
 }
 
 /// @docsEditable true
 class MediaStreamTrackListEvents extends Events {
   /// @docsEditable true
   MediaStreamTrackListEvents(EventTarget _ptr) : super(_ptr);
 
   /// @docsEditable true
   EventListenerList get addTrack => this['addtrack'];
 
@@ skipping 93 matching lines @@
   void webkitInitMessageEvent(String typeArg, bool canBubbleArg, bool cancelableArg, Object dataArg, String originArg, String lastEventIdArg, Window sourceArg, List transferables) native;
 }
 // Copyright (c) 2012, 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.
 
 
 /// @domName MessagePort; @docsEditable true
 class MessagePort extends EventTarget native "*MessagePort" {
 
+  static const EventStreamProvider<MessageEvent> messageEvent = const EventStreamProvider<MessageEvent>('message');
+
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   MessagePortEvents get on =>
     new MessagePortEvents(this);
 
   /// @domName MessagePort.addEventListener; @docsEditable true
   @JSName('addEventListener')
   void $dom_addEventListener(String type, EventListener listener, [bool useCapture]) native;
 
   /// @domName MessagePort.close; @docsEditable true
   void close() native;
@@ skipping 17 matching lines @@
   void _postMessage_1(message, List messagePorts) native;
   @JSName('postMessage')
   void _postMessage_2(message) native;
 
   /// @domName MessagePort.removeEventListener; @docsEditable true
   @JSName('removeEventListener')
   void $dom_removeEventListener(String type, EventListener listener, [bool useCapture]) native;
 
   /// @domName MessagePort.start; @docsEditable true
   void start() native;
+
+  Stream<MessageEvent> get onMessage => messageEvent.forTarget(this);
 }
 
 /// @docsEditable true
 class MessagePortEvents extends Events {
   /// @docsEditable true
   MessagePortEvents(EventTarget _ptr) : super(_ptr);
 
   /// @docsEditable true
   EventListenerList get message => this['message'];
 }
@@ skipping 1286 matching lines @@
   final String systemId;
 }
 // Copyright (c) 2012, 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.
 
 
 /// @domName Notification; @docsEditable true
 class Notification extends EventTarget native "*Notification" {
 
+  static const EventStreamProvider<Event> clickEvent = const EventStreamProvider<Event>('click');
+
+  static const EventStreamProvider<Event> closeEvent = const EventStreamProvider<Event>('close');
+
+  static const EventStreamProvider<Event> displayEvent = const EventStreamProvider<Event>('display');
+
+  static const EventStreamProvider<Event> errorEvent = const EventStreamProvider<Event>('error');
+
+  static const EventStreamProvider<Event> showEvent = const EventStreamProvider<Event>('show');
+
   ///@docsEditable true
   factory Notification(String title, [Map options]) {
     if (!?options) {
       return Notification._create(title);
     }
     return Notification._create(title, options);
   }
   static Notification _create(String title, [Map options]) {
     if (!?options) {
       return JS('Notification', 'new Notification(#)', title);
@@ skipping 33 matching lines @@
 
   /// @domName Notification.removeEventListener; @docsEditable true
   @JSName('removeEventListener')
   void $dom_removeEventListener(String type, EventListener listener, [bool useCapture]) native;
 
   /// @domName Notification.requestPermission; @docsEditable true
   static void requestPermission(NotificationPermissionCallback callback) native;
 
   /// @domName Notification.show; @docsEditable true
   void show() native;
+
+  Stream<Event> get onClick => clickEvent.forTarget(this);
+
+  Stream<Event> get onClose => closeEvent.forTarget(this);
+
+  Stream<Event> get onDisplay => displayEvent.forTarget(this);
+
+  Stream<Event> get onError => errorEvent.forTarget(this);
+
+  Stream<Event> get onShow => showEvent.forTarget(this);
 }
 
 /// @docsEditable true
 class NotificationEvents extends Events {
   /// @docsEditable true
   NotificationEvents(EventTarget _ptr) : super(_ptr);
 
   /// @docsEditable true
   EventListenerList get click => this['click'];
 
@@ skipping 885 matching lines @@
   final CssPrimitiveValue red;
 }
 // Copyright (c) 2012, 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.
 
 
 /// @domName RTCDataChannel; @docsEditable true
 class RtcDataChannel extends EventTarget native "*RTCDataChannel" {
 
+  static const EventStreamProvider<Event> closeEvent = const EventStreamProvider<Event>('close');
+
+  static const EventStreamProvider<Event> errorEvent = const EventStreamProvider<Event>('error');
+
+  static const EventStreamProvider<MessageEvent> messageEvent = const EventStreamProvider<MessageEvent>('message');
+
+  static const EventStreamProvider<Event> openEvent = const EventStreamProvider<Event>('open');
+
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   RtcDataChannelEvents get on =>
     new RtcDataChannelEvents(this);
 
   /// @domName RTCDataChannel.binaryType; @docsEditable true
   String binaryType;
 
   /// @domName RTCDataChannel.bufferedAmount; @docsEditable true
   final int bufferedAmount;
 
@@ skipping 16 matching lines @@
   /// @domName RTCDataChannel.dispatchEvent; @docsEditable true
   @JSName('dispatchEvent')
   bool $dom_dispatchEvent(Event event) native;
 
   /// @domName RTCDataChannel.removeEventListener; @docsEditable true
   @JSName('removeEventListener')
   void $dom_removeEventListener(String type, EventListener listener, [bool useCapture]) native;
 
   /// @domName RTCDataChannel.send; @docsEditable true
   void send(data) native;
+
+  Stream<Event> get onClose => closeEvent.forTarget(this);
+
+  Stream<Event> get onError => errorEvent.forTarget(this);
+
+  Stream<MessageEvent> get onMessage => messageEvent.forTarget(this);
+
+  Stream<Event> get onOpen => openEvent.forTarget(this);
 }
 
 /// @docsEditable true
 class RtcDataChannelEvents extends Events {
   /// @docsEditable true
   RtcDataChannelEvents(EventTarget _ptr) : super(_ptr);
 
   /// @docsEditable true
   EventListenerList get close => this['close'];
 
@@ skipping 50 matching lines @@
   final RtcIceCandidate candidate;
 }
 // Copyright (c) 2012, 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.
 
 
 /// @domName RTCPeerConnection; @docsEditable true
 class RtcPeerConnection extends EventTarget native "*RTCPeerConnection" {
 
+  static const EventStreamProvider<MediaStreamEvent> addStreamEvent = const EventStreamProvider<MediaStreamEvent>('addstream');
+
+  static const EventStreamProvider<RtcDataChannelEvent> dataChannelEvent = const EventStreamProvider<RtcDataChannelEvent>('datachannel');
+
+  static const EventStreamProvider<RtcIceCandidateEvent> iceCandidateEvent = const EventStreamProvider<RtcIceCandidateEvent>('icecandidate');
+
+  static const EventStreamProvider<Event> iceChangeEvent = const EventStreamProvider<Event>('icechange');
+
+  static const EventStreamProvider<Event> negotiationNeededEvent = const EventStreamProvider<Event>('negotiationneeded');
+
+  static const EventStreamProvider<Event> openEvent = const EventStreamProvider<Event>('open');
+
+  static const EventStreamProvider<MediaStreamEvent> removeStreamEvent = const EventStreamProvider<MediaStreamEvent>('removestream');
+
+  static const EventStreamProvider<Event> stateChangeEvent = const EventStreamProvider<Event>('statechange');
+
   ///@docsEditable true
   factory RtcPeerConnection(Map rtcIceServers, [Map mediaConstraints]) {
     if (!?mediaConstraints) {
       return RtcPeerConnection._create(rtcIceServers);
     }
     return RtcPeerConnection._create(rtcIceServers, mediaConstraints);
   }
   static RtcPeerConnection _create(Map rtcIceServers, [Map mediaConstraints]) {
     if (!?mediaConstraints) {
       return JS('RtcPeerConnection', 'new RTCPeerConnection(#)', rtcIceServers);
@@ skipping 131 matching lines @@
     }
     _updateIce_3();
     return;
   }
   @JSName('updateIce')
   void _updateIce_1(configuration, mediaConstraints) native;
   @JSName('updateIce')
   void _updateIce_2(configuration) native;
   @JSName('updateIce')
   void _updateIce_3() native;
+
+  Stream<MediaStreamEvent> get onAddStream => addStreamEvent.forTarget(this);
+
+  Stream<RtcDataChannelEvent> get onDataChannel => dataChannelEvent.forTarget(this);
+
+  Stream<RtcIceCandidateEvent> get onIceCandidate => iceCandidateEvent.forTarget(this);
+
+  Stream<Event> get onIceChange => iceChangeEvent.forTarget(this);
+
+  Stream<Event> get onNegotiationNeeded => negotiationNeededEvent.forTarget(this);
+
+  Stream<Event> get onOpen => openEvent.forTarget(this);
+
+  Stream<MediaStreamEvent> get onRemoveStream => removeStreamEvent.forTarget(this);
+
+  Stream<Event> get onStateChange => stateChangeEvent.forTarget(this);
 }
 
 /// @docsEditable true
 class RtcPeerConnectionEvents extends Events {
   /// @docsEditable true
   RtcPeerConnectionEvents(EventTarget _ptr) : super(_ptr);
 
   /// @docsEditable true
   EventListenerList get addStream => this['addstream'];
 
@@ skipping 418 matching lines @@
   final MessagePort port;
 }
 // Copyright (c) 2012, 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.
 
 
 /// @domName SharedWorkerContext; @docsEditable true
 class SharedWorkerContext extends WorkerContext native "*SharedWorkerContext" {
 
+  static const EventStreamProvider<Event> connectEvent = const EventStreamProvider<Event>('connect');
+
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   SharedWorkerContextEvents get on =>
     new SharedWorkerContextEvents(this);
 
   /// @domName SharedWorkerContext.name; @docsEditable true
   final String name;
+
+  Stream<Event> get onConnect => connectEvent.forTarget(this);
 }
 
 /// @docsEditable true
 class SharedWorkerContextEvents extends WorkerContextEvents {
   /// @docsEditable true
   SharedWorkerContextEvents(EventTarget _ptr) : super(_ptr);
 
   /// @docsEditable true
   EventListenerList get connect => this['connect'];
 }
@@ skipping 433 matching lines @@
   final String utterance;
 }
 // Copyright (c) 2012, 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.
 
 
 /// @domName SpeechRecognition; @docsEditable true
 class SpeechRecognition extends EventTarget native "*SpeechRecognition" {
 
+  static const EventStreamProvider<Event> audioEndEvent = const EventStreamProvider<Event>('audioend');
+
+  static const EventStreamProvider<Event> audioStartEvent = const EventStreamProvider<Event>('audiostart');
+
+  static const EventStreamProvider<Event> endEvent = const EventStreamProvider<Event>('end');
+
+  static const EventStreamProvider<SpeechRecognitionError> errorEvent = const EventStreamProvider<SpeechRecognitionError>('error');
+
+  static const EventStreamProvider<SpeechRecognitionEvent> noMatchEvent = const EventStreamProvider<SpeechRecognitionEvent>('nomatch');
+
+  static const EventStreamProvider<SpeechRecognitionEvent> resultEvent = const EventStreamProvider<SpeechRecognitionEvent>('result');
+
+  static const EventStreamProvider<Event> soundEndEvent = const EventStreamProvider<Event>('soundend');
+
+  static const EventStreamProvider<Event> soundStartEvent = const EventStreamProvider<Event>('soundstart');
+
+  static const EventStreamProvider<Event> speechEndEvent = const EventStreamProvider<Event>('speechend');
+
+  static const EventStreamProvider<Event> speechStartEvent = const EventStreamProvider<Event>('speechstart');
+
+  static const EventStreamProvider<Event> startEvent = const EventStreamProvider<Event>('start');
+
   ///@docsEditable true
   factory SpeechRecognition() => SpeechRecognition._create();
   static SpeechRecognition _create() => JS('SpeechRecognition', 'new SpeechRecognition()');
 
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   SpeechRecognitionEvents get on =>
     new SpeechRecognitionEvents(this);
 
   /// @domName SpeechRecognition.continuous; @docsEditable true
   bool continuous;
@@ skipping 23 matching lines @@
 
   /// @domName SpeechRecognition.removeEventListener; @docsEditable true
   @JSName('removeEventListener')
   void $dom_removeEventListener(String type, EventListener listener, [bool useCapture]) native;
 
   /// @domName SpeechRecognition.start; @docsEditable true
   void start() native;
 
   /// @domName SpeechRecognition.stop; @docsEditable true
   void stop() native;
+
+  Stream<Event> get onAudioEnd => audioEndEvent.forTarget(this);
+
+  Stream<Event> get onAudioStart => audioStartEvent.forTarget(this);
+
+  Stream<Event> get onEnd => endEvent.forTarget(this);
+
+  Stream<SpeechRecognitionError> get onError => errorEvent.forTarget(this);
+
+  Stream<SpeechRecognitionEvent> get onNoMatch => noMatchEvent.forTarget(this);
+
+  Stream<SpeechRecognitionEvent> get onResult => resultEvent.forTarget(this);
+
+  Stream<Event> get onSoundEnd => soundEndEvent.forTarget(this);
+
+  Stream<Event> get onSoundStart => soundStartEvent.forTarget(this);
+
+  Stream<Event> get onSpeechEnd => speechEndEvent.forTarget(this);
+
+  Stream<Event> get onSpeechStart => speechStartEvent.forTarget(this);
+
+  Stream<Event> get onStart => startEvent.forTarget(this);
 }
 
 /// @docsEditable true
 class SpeechRecognitionEvents extends Events {
   /// @docsEditable true
   SpeechRecognitionEvents(EventTarget _ptr) : super(_ptr);
 
   /// @docsEditable true
   EventListenerList get audioEnd => this['audioend'];
 
@@ skipping 885 matching lines @@
   final num width;
 }
 // Copyright (c) 2012, 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.
 
 
 /// @domName TextTrack; @docsEditable true
 class TextTrack extends EventTarget native "*TextTrack" {
 
+  static const EventStreamProvider<Event> cueChangeEvent = const EventStreamProvider<Event>('cuechange');
+
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   TextTrackEvents get on =>
     new TextTrackEvents(this);
 
   /// @domName TextTrack.activeCues; @docsEditable true
   final TextTrackCueList activeCues;
 
   /// @domName TextTrack.cues; @docsEditable true
   final TextTrackCueList cues;
 
@@ skipping 19 matching lines @@
   /// @domName TextTrack.dispatchEvent; @docsEditable true
   @JSName('dispatchEvent')
   bool $dom_dispatchEvent(Event evt) native;
 
   /// @domName TextTrack.removeCue; @docsEditable true
   void removeCue(TextTrackCue cue) native;
 
   /// @domName TextTrack.removeEventListener; @docsEditable true
   @JSName('removeEventListener')
   void $dom_removeEventListener(String type, EventListener listener, [bool useCapture]) native;
+
+  Stream<Event> get onCueChange => cueChangeEvent.forTarget(this);
 }
 
 /// @docsEditable true
 class TextTrackEvents extends Events {
   /// @docsEditable true
   TextTrackEvents(EventTarget _ptr) : super(_ptr);
 
   /// @docsEditable true
   EventListenerList get cueChange => this['cuechange'];
 }
 // Copyright (c) 2012, 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.
 
 
 /// @domName TextTrackCue; @docsEditable true
 class TextTrackCue extends EventTarget native "*TextTrackCue" {
 
+  static const EventStreamProvider<Event> enterEvent = const EventStreamProvider<Event>('enter');
+
+  static const EventStreamProvider<Event> exitEvent = const EventStreamProvider<Event>('exit');
+
   ///@docsEditable true
   factory TextTrackCue(num startTime, num endTime, String text) => TextTrackCue._create(startTime, endTime, text);
   static TextTrackCue _create(num startTime, num endTime, String text) => JS('TextTrackCue', 'new TextTrackCue(#,#,#)', startTime, endTime, text);
 
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   TextTrackCueEvents get on =>
     new TextTrackCueEvents(this);
 
   /// @domName TextTrackCue.align; @docsEditable true
   String align;
@@ skipping 39 matching lines @@
   @JSName('dispatchEvent')
   bool $dom_dispatchEvent(Event evt) native;
 
   /// @domName TextTrackCue.getCueAsHTML; @docsEditable true
   @JSName('getCueAsHTML')
   DocumentFragment getCueAsHtml() native;
 
   /// @domName TextTrackCue.removeEventListener; @docsEditable true
   @JSName('removeEventListener')
   void $dom_removeEventListener(String type, EventListener listener, [bool useCapture]) native;
+
+  Stream<Event> get onEnter => enterEvent.forTarget(this);
+
+  Stream<Event> get onExit => exitEvent.forTarget(this);
 }
 
 /// @docsEditable true
 class TextTrackCueEvents extends Events {
   /// @docsEditable true
   TextTrackCueEvents(EventTarget _ptr) : super(_ptr);
 
   /// @docsEditable true
   EventListenerList get enter => this['enter'];
 
@@ skipping 163 matching lines @@
   TextTrackCue item(int index) native;
 }
 // Copyright (c) 2012, 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.
 
 
 /// @domName TextTrackList; @docsEditable true
 class TextTrackList extends EventTarget implements JavaScriptIndexingBehavior, List<TextTrack> native "*TextTrackList" {
 
+  static const EventStreamProvider<TrackEvent> addTrackEvent = const EventStreamProvider<TrackEvent>('addtrack');
+
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   TextTrackListEvents get on =>
     new TextTrackListEvents(this);
 
   /// @domName TextTrackList.length; @docsEditable true
   int get length => JS("int", "#.length", this);
 
   TextTrack operator[](int index) => JS("TextTrack", "#[#]", this, index);
 
   void operator[]=(int index, TextTrack value) {
@@ skipping 146 matching lines @@
   /// @domName TextTrackList.dispatchEvent; @docsEditable true
   @JSName('dispatchEvent')
   bool $dom_dispatchEvent(Event evt) native;
 
   /// @domName TextTrackList.item; @docsEditable true
   TextTrack item(int index) native;
 
   /// @domName TextTrackList.removeEventListener; @docsEditable true
   @JSName('removeEventListener')
   void $dom_removeEventListener(String type, EventListener listener, [bool useCapture]) native;
+
+  Stream<TrackEvent> get onAddTrack => addTrackEvent.forTarget(this);
 }
 
 /// @docsEditable true
 class TextTrackListEvents extends Events {
   /// @docsEditable true
   TextTrackListEvents(EventTarget _ptr) : super(_ptr);
 
   /// @docsEditable true
   EventListenerList get addTrack => this['addtrack'];
 }
@@ skipping 2509 matching lines @@
 // BSD-style license that can be found in the LICENSE file.
 
 
 /// @domName WebSocket; @docsEditable true
 @SupportedBrowser(SupportedBrowser.CHROME)
 @SupportedBrowser(SupportedBrowser.FIREFOX)
 @SupportedBrowser(SupportedBrowser.IE, '10')
 @SupportedBrowser(SupportedBrowser.SAFARI)
 class WebSocket extends EventTarget native "*WebSocket" {
 
+  static const EventStreamProvider<CloseEvent> closeEvent = const EventStreamProvider<CloseEvent>('close');
+
+  static const EventStreamProvider<Event> errorEvent = const EventStreamProvider<Event>('error');
+
+  static const EventStreamProvider<MessageEvent> messageEvent = const EventStreamProvider<MessageEvent>('message');
+
+  static const EventStreamProvider<Event> openEvent = const EventStreamProvider<Event>('open');
+
   ///@docsEditable true
   factory WebSocket(String url) => WebSocket._create(url);
   static WebSocket _create(String url) => JS('WebSocket', 'new WebSocket(#)', url);
 
   /**
    * Checks if this type is supported on the current platform
    */
   static bool get supported => JS('bool', 'typeof window.WebSocket != "undefined"');
 
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
@@ skipping 40 matching lines @@
   /// @domName WebSocket.dispatchEvent; @docsEditable true
   @JSName('dispatchEvent')
   bool $dom_dispatchEvent(Event evt) native;
 
   /// @domName WebSocket.removeEventListener; @docsEditable true
   @JSName('removeEventListener')
   void $dom_removeEventListener(String type, EventListener listener, [bool useCapture]) native;
 
   /// @domName WebSocket.send; @docsEditable true
   bool send(data) native;
+
+  Stream<CloseEvent> get onClose => closeEvent.forTarget(this);
+
+  Stream<Event> get onError => errorEvent.forTarget(this);
+
+  Stream<MessageEvent> get onMessage => messageEvent.forTarget(this);
+
+  Stream<Event> get onOpen => openEvent.forTarget(this);
 }
 
 /// @docsEditable true
 class WebSocketEvents extends Events {
   /// @docsEditable true
   WebSocketEvents(EventTarget _ptr) : super(_ptr);
 
   /// @docsEditable true
   EventListenerList get close => this['close'];
 
@@ skipping 249 matching lines @@
    */
   void registerPort(String name, var port) {
     var serialized = _serialize(port);
     document.documentElement.attributes['dart-port:$name'] = json.stringify(serialized);
   }
 
   /// @domName Window.console; @docsEditable true
   Console get console => Console.safeConsole;
 
 
+  static const EventStreamProvider<Event> contentLoadedEvent = const EventStreamProvider<Event>('DOMContentLoaded');
+
+  static const EventStreamProvider<Event> abortEvent = const EventStreamProvider<Event>('abort');
+
+  static const EventStreamProvider<Event> beforeUnloadEvent = const EventStreamProvider<Event>('beforeunload');
+
+  static const EventStreamProvider<Event> blurEvent = const EventStreamProvider<Event>('blur');
+
+  static const EventStreamProvider<Event> canPlayEvent = const EventStreamProvider<Event>('canplay');
+
+  static const EventStreamProvider<Event> canPlayThroughEvent = const EventStreamProvider<Event>('canplaythrough');
+
+  static const EventStreamProvider<Event> changeEvent = const EventStreamProvider<Event>('change');
+
+  static const EventStreamProvider<MouseEvent> clickEvent = const EventStreamProvider<MouseEvent>('click');
+
+  static const EventStreamProvider<MouseEvent> contextMenuEvent = const EventStreamProvider<MouseEvent>('contextmenu');
+
+  static const EventStreamProvider<Event> doubleClickEvent = const EventStreamProvider<Event>('dblclick');
+
+  static const EventStreamProvider<DeviceMotionEvent> deviceMotionEvent = const EventStreamProvider<DeviceMotionEvent>('devicemotion');
+
+  static const EventStreamProvider<DeviceOrientationEvent> deviceOrientationEvent = const EventStreamProvider<DeviceOrientationEvent>('deviceorientation');
+
+  static const EventStreamProvider<MouseEvent> dragEvent = const EventStreamProvider<MouseEvent>('drag');
+
+  static const EventStreamProvider<MouseEvent> dragEndEvent = const EventStreamProvider<MouseEvent>('dragend');
+
+  static const EventStreamProvider<MouseEvent> dragEnterEvent = const EventStreamProvider<MouseEvent>('dragenter');
+
+  static const EventStreamProvider<MouseEvent> dragLeaveEvent = const EventStreamProvider<MouseEvent>('dragleave');
+
+  static const EventStreamProvider<MouseEvent> dragOverEvent = const EventStreamProvider<MouseEvent>('dragover');
+
+  static const EventStreamProvider<MouseEvent> dragStartEvent = const EventStreamProvider<MouseEvent>('dragstart');
+
+  static const EventStreamProvider<MouseEvent> dropEvent = const EventStreamProvider<MouseEvent>('drop');
+
+  static const EventStreamProvider<Event> durationChangeEvent = const EventStreamProvider<Event>('durationchange');
+
+  static const EventStreamProvider<Event> emptiedEvent = const EventStreamProvider<Event>('emptied');
+
+  static const EventStreamProvider<Event> endedEvent = const EventStreamProvider<Event>('ended');
+
+  static const EventStreamProvider<Event> errorEvent = const EventStreamProvider<Event>('error');
+
+  static const EventStreamProvider<Event> focusEvent = const EventStreamProvider<Event>('focus');
+
+  static const EventStreamProvider<HashChangeEvent> hashChangeEvent = const EventStreamProvider<HashChangeEvent>('hashchange');
+
+  static const EventStreamProvider<Event> inputEvent = const EventStreamProvider<Event>('input');
+
+  static const EventStreamProvider<Event> invalidEvent = const EventStreamProvider<Event>('invalid');
+
+  static const EventStreamProvider<KeyboardEvent> keyDownEvent = const EventStreamProvider<KeyboardEvent>('keydown');
+
+  static const EventStreamProvider<KeyboardEvent> keyPressEvent = const EventStreamProvider<KeyboardEvent>('keypress');
+
+  static const EventStreamProvider<KeyboardEvent> keyUpEvent = const EventStreamProvider<KeyboardEvent>('keyup');
+
+  static const EventStreamProvider<Event> loadEvent = const EventStreamProvider<Event>('load');
+
+  static const EventStreamProvider<Event> loadedDataEvent = const EventStreamProvider<Event>('loadeddata');
+
+  static const EventStreamProvider<Event> loadedMetadataEvent = const EventStreamProvider<Event>('loadedmetadata');
+
+  static const EventStreamProvider<Event> loadStartEvent = const EventStreamProvider<Event>('loadstart');
+
+  static const EventStreamProvider<MessageEvent> messageEvent = const EventStreamProvider<MessageEvent>('message');
+
+  static const EventStreamProvider<MouseEvent> mouseDownEvent = const EventStreamProvider<MouseEvent>('mousedown');
+
+  static const EventStreamProvider<MouseEvent> mouseMoveEvent = const EventStreamProvider<MouseEvent>('mousemove');
+
+  static const EventStreamProvider<MouseEvent> mouseOutEvent = const EventStreamProvider<MouseEvent>('mouseout');
+
+  static const EventStreamProvider<MouseEvent> mouseOverEvent = const EventStreamProvider<MouseEvent>('mouseover');
+
+  static const EventStreamProvider<MouseEvent> mouseUpEvent = const EventStreamProvider<MouseEvent>('mouseup');
+
+  static const EventStreamProvider<WheelEvent> mouseWheelEvent = const EventStreamProvider<WheelEvent>('mousewheel');
+
+  static const EventStreamProvider<Event> offlineEvent = const EventStreamProvider<Event>('offline');
+
+  static const EventStreamProvider<Event> onlineEvent = const EventStreamProvider<Event>('online');
+
+  static const EventStreamProvider<Event> pageHideEvent = const EventStreamProvider<Event>('pagehide');
+
+  static const EventStreamProvider<Event> pageShowEvent = const EventStreamProvider<Event>('pageshow');
+
+  static const EventStreamProvider<Event> pauseEvent = const EventStreamProvider<Event>('pause');
+
+  static const EventStreamProvider<Event> playEvent = const EventStreamProvider<Event>('play');
+
+  static const EventStreamProvider<Event> playingEvent = const EventStreamProvider<Event>('playing');
+
+  static const EventStreamProvider<PopStateEvent> popStateEvent = const EventStreamProvider<PopStateEvent>('popstate');
+
+  static const EventStreamProvider<Event> progressEvent = const EventStreamProvider<Event>('progress');
+
+  static const EventStreamProvider<Event> rateChangeEvent = const EventStreamProvider<Event>('ratechange');
+
+  static const EventStreamProvider<Event> resetEvent = const EventStreamProvider<Event>('reset');
+
+  static const EventStreamProvider<Event> resizeEvent = const EventStreamProvider<Event>('resize');
+
+  static const EventStreamProvider<Event> scrollEvent = const EventStreamProvider<Event>('scroll');
+
+  static const EventStreamProvider<Event> searchEvent = const EventStreamProvider<Event>('search');
+
+  static const EventStreamProvider<Event> seekedEvent = const EventStreamProvider<Event>('seeked');
+
+  static const EventStreamProvider<Event> seekingEvent = const EventStreamProvider<Event>('seeking');
+
+  static const EventStreamProvider<Event> selectEvent = const EventStreamProvider<Event>('select');
+
+  static const EventStreamProvider<Event> stalledEvent = const EventStreamProvider<Event>('stalled');
+
+  static const EventStreamProvider<StorageEvent> storageEvent = const EventStreamProvider<StorageEvent>('storage');
+
+  static const EventStreamProvider<Event> submitEvent = const EventStreamProvider<Event>('submit');
+
+  static const EventStreamProvider<Event> suspendEvent = const EventStreamProvider<Event>('suspend');
+
+  static const EventStreamProvider<Event> timeUpdateEvent = const EventStreamProvider<Event>('timeupdate');
+
+  static const EventStreamProvider<TouchEvent> touchCancelEvent = const EventStreamProvider<TouchEvent>('touchcancel');
+
+  static const EventStreamProvider<TouchEvent> touchEndEvent = const EventStreamProvider<TouchEvent>('touchend');
+
+  static const EventStreamProvider<TouchEvent> touchMoveEvent = const EventStreamProvider<TouchEvent>('touchmove');
+
+  static const EventStreamProvider<TouchEvent> touchStartEvent = const EventStreamProvider<TouchEvent>('touchstart');
+
+  static const EventStreamProvider<Event> unloadEvent = const EventStreamProvider<Event>('unload');
+
+  static const EventStreamProvider<Event> volumeChangeEvent = const EventStreamProvider<Event>('volumechange');
+
+  static const EventStreamProvider<Event> waitingEvent = const EventStreamProvider<Event>('waiting');
+
+  static const EventStreamProvider<AnimationEvent> animationEndEvent = const EventStreamProvider<AnimationEvent>('webkitAnimationEnd');
+
+  static const EventStreamProvider<AnimationEvent> animationIterationEvent = const EventStreamProvider<AnimationEvent>('webkitAnimationIteration');
+
+  static const EventStreamProvider<AnimationEvent> animationStartEvent = const EventStreamProvider<AnimationEvent>('webkitAnimationStart');
+
+  static const EventStreamProvider<TransitionEvent> transitionEndEvent = const EventStreamProvider<TransitionEvent>('webkitTransitionEnd');
+
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   WindowEvents get on =>
     new WindowEvents(this);
 
   static const int PERSISTENT = 1;
 
   static const int TEMPORARY = 0;
 
   /// @domName Window.applicationCache; @docsEditable true
   final ApplicationCache applicationCache;
@@ skipping 262 matching lines @@
   /// @domName Window.webkitConvertPointFromPageToNode; @docsEditable true
   Point webkitConvertPointFromPageToNode(Node node, Point p) native;
 
   /// @domName DOMWindow.webkitRequestFileSystem; @docsEditable true
   void webkitRequestFileSystem(int type, int size, FileSystemCallback successCallback, [ErrorCallback errorCallback]) native;
 
   /// @domName DOMWindow.webkitResolveLocalFileSystemURL; @docsEditable true
   @JSName('webkitResolveLocalFileSystemURL')
   void webkitResolveLocalFileSystemUrl(String url, EntryCallback successCallback, [ErrorCallback errorCallback]) native;
 
+  Stream<Event> get onContentLoaded => contentLoadedEvent.forTarget(this);
+
+  Stream<Event> get onAbort => abortEvent.forTarget(this);
+
+  Stream<Event> get onBeforeUnload => beforeUnloadEvent.forTarget(this);
+
+  Stream<Event> get onBlur => blurEvent.forTarget(this);
+
+  Stream<Event> get onCanPlay => canPlayEvent.forTarget(this);
+
+  Stream<Event> get onCanPlayThrough => canPlayThroughEvent.forTarget(this);
+
+  Stream<Event> get onChange => changeEvent.forTarget(this);
+
+  Stream<MouseEvent> get onClick => clickEvent.forTarget(this);
+
+  Stream<MouseEvent> get onContextMenu => contextMenuEvent.forTarget(this);
+
+  Stream<Event> get onDoubleClick => doubleClickEvent.forTarget(this);
+
+  Stream<DeviceMotionEvent> get onDeviceMotion => deviceMotionEvent.forTarget(this);
+
+  Stream<DeviceOrientationEvent> get onDeviceOrientation => deviceOrientationEvent.forTarget(this);
+
+  Stream<MouseEvent> get onDrag => dragEvent.forTarget(this);
+
+  Stream<MouseEvent> get onDragEnd => dragEndEvent.forTarget(this);
+
+  Stream<MouseEvent> get onDragEnter => dragEnterEvent.forTarget(this);
+
+  Stream<MouseEvent> get onDragLeave => dragLeaveEvent.forTarget(this);
+
+  Stream<MouseEvent> get onDragOver => dragOverEvent.forTarget(this);
+
+  Stream<MouseEvent> get onDragStart => dragStartEvent.forTarget(this);
+
+  Stream<MouseEvent> get onDrop => dropEvent.forTarget(this);
+
+  Stream<Event> get onDurationChange => durationChangeEvent.forTarget(this);
+
+  Stream<Event> get onEmptied => emptiedEvent.forTarget(this);
+
+  Stream<Event> get onEnded => endedEvent.forTarget(this);
+
+  Stream<Event> get onError => errorEvent.forTarget(this);
+
+  Stream<Event> get onFocus => focusEvent.forTarget(this);
+
+  Stream<HashChangeEvent> get onHashChange => hashChangeEvent.forTarget(this);
+
+  Stream<Event> get onInput => inputEvent.forTarget(this);
+
+  Stream<Event> get onInvalid => invalidEvent.forTarget(this);
+
+  Stream<KeyboardEvent> get onKeyDown => keyDownEvent.forTarget(this);
+
+  Stream<KeyboardEvent> get onKeyPress => keyPressEvent.forTarget(this);
+
+  Stream<KeyboardEvent> get onKeyUp => keyUpEvent.forTarget(this);
+
+  Stream<Event> get onLoad => loadEvent.forTarget(this);
+
+  Stream<Event> get onLoadedData => loadedDataEvent.forTarget(this);
+
+  Stream<Event> get onLoadedMetadata => loadedMetadataEvent.forTarget(this);
+
+  Stream<Event> get onLoadStart => loadStartEvent.forTarget(this);
+
+  Stream<MessageEvent> get onMessage => messageEvent.forTarget(this);
+
+  Stream<MouseEvent> get onMouseDown => mouseDownEvent.forTarget(this);
+
+  Stream<MouseEvent> get onMouseMove => mouseMoveEvent.forTarget(this);
+
+  Stream<MouseEvent> get onMouseOut => mouseOutEvent.forTarget(this);
+
+  Stream<MouseEvent> get onMouseOver => mouseOverEvent.forTarget(this);
+
+  Stream<MouseEvent> get onMouseUp => mouseUpEvent.forTarget(this);
+
+  Stream<WheelEvent> get onMouseWheel => mouseWheelEvent.forTarget(this);
+
+  Stream<Event> get onOffline => offlineEvent.forTarget(this);
+
+  Stream<Event> get onOnline => onlineEvent.forTarget(this);
+
+  Stream<Event> get onPageHide => pageHideEvent.forTarget(this);
+
+  Stream<Event> get onPageShow => pageShowEvent.forTarget(this);
+
+  Stream<Event> get onPause => pauseEvent.forTarget(this);
+
+  Stream<Event> get onPlay => playEvent.forTarget(this);
+
+  Stream<Event> get onPlaying => playingEvent.forTarget(this);
+
+  Stream<PopStateEvent> get onPopState => popStateEvent.forTarget(this);
+
+  Stream<Event> get onProgress => progressEvent.forTarget(this);
+
+  Stream<Event> get onRateChange => rateChangeEvent.forTarget(this);
+
+  Stream<Event> get onReset => resetEvent.forTarget(this);
+
+  Stream<Event> get onResize => resizeEvent.forTarget(this);
+
+  Stream<Event> get onScroll => scrollEvent.forTarget(this);
+
+  Stream<Event> get onSearch => searchEvent.forTarget(this);
+
+  Stream<Event> get onSeeked => seekedEvent.forTarget(this);
+
+  Stream<Event> get onSeeking => seekingEvent.forTarget(this);
+
+  Stream<Event> get onSelect => selectEvent.forTarget(this);
+
+  Stream<Event> get onStalled => stalledEvent.forTarget(this);
+
+  Stream<StorageEvent> get onStorage => storageEvent.forTarget(this);
+
+  Stream<Event> get onSubmit => submitEvent.forTarget(this);
+
+  Stream<Event> get onSuspend => suspendEvent.forTarget(this);
+
+  Stream<Event> get onTimeUpdate => timeUpdateEvent.forTarget(this);
+
+  Stream<TouchEvent> get onTouchCancel => touchCancelEvent.forTarget(this);
+
+  Stream<TouchEvent> get onTouchEnd => touchEndEvent.forTarget(this);
+
+  Stream<TouchEvent> get onTouchMove => touchMoveEvent.forTarget(this);
+
+  Stream<TouchEvent> get onTouchStart => touchStartEvent.forTarget(this);
+
+  Stream<Event> get onUnload => unloadEvent.forTarget(this);
+
+  Stream<Event> get onVolumeChange => volumeChangeEvent.forTarget(this);
+
+  Stream<Event> get onWaiting => waitingEvent.forTarget(this);
+
+  Stream<AnimationEvent> get onAnimationEnd => animationEndEvent.forTarget(this);
+
+  Stream<AnimationEvent> get onAnimationIteration => animationIterationEvent.forTarget(this);
+
+  Stream<AnimationEvent> get onAnimationStart => animationStartEvent.forTarget(this);
+
+  Stream<TransitionEvent> get onTransitionEnd => transitionEndEvent.forTarget(this);
+
 }
 
 /// @docsEditable true
 class WindowEvents extends Events {
   /// @docsEditable true
   WindowEvents(EventTarget _ptr) : super(_ptr);
 
   /// @docsEditable true
   EventListenerList get contentLoaded => this['DOMContentLoaded'];
 
@@ skipping 217 matching lines @@
   EventListenerList get transitionEnd => this['webkitTransitionEnd'];
 }
 // Copyright (c) 2012, 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.
 
 
 /// @domName Worker; @docsEditable true
 class Worker extends AbstractWorker native "*Worker" {
 
+  static const EventStreamProvider<MessageEvent> messageEvent = const EventStreamProvider<MessageEvent>('message');
+
   ///@docsEditable true
   factory Worker(String scriptUrl) => Worker._create(scriptUrl);
   static Worker _create(String scriptUrl) => JS('Worker', 'new Worker(#)', scriptUrl);
 
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   WorkerEvents get on =>
     new WorkerEvents(this);
 
   /// @domName Worker.postMessage; @docsEditable true
   void postMessage(/*SerializedScriptValue*/ message, [List messagePorts]) {
     if (?messagePorts) {
       var message_1 = convertDartToNative_SerializedScriptValue(message);
       _postMessage_1(message_1, messagePorts);
       return;
     }
     var message_2 = convertDartToNative_SerializedScriptValue(message);
     _postMessage_2(message_2);
     return;
   }
   @JSName('postMessage')
   void _postMessage_1(message, List messagePorts) native;
   @JSName('postMessage')
   void _postMessage_2(message) native;
 
   /// @domName Worker.terminate; @docsEditable true
   void terminate() native;
+
+  Stream<MessageEvent> get onMessage => messageEvent.forTarget(this);
 }
 
 /// @docsEditable true
 class WorkerEvents extends AbstractWorkerEvents {
   /// @docsEditable true
   WorkerEvents(EventTarget _ptr) : super(_ptr);
 
   /// @docsEditable true
   EventListenerList get message => this['message'];
 }
 // Copyright (c) 2012, 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.
 
 
 /// @domName WorkerContext
 class WorkerContext extends EventTarget native "*WorkerContext" {
 
+  static const EventStreamProvider<Event> errorEvent = const EventStreamProvider<Event>('error');
+
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   WorkerContextEvents get on =>
     new WorkerContextEvents(this);
 
   static const int PERSISTENT = 1;
 
   static const int TEMPORARY = 0;
 
   /// @domName WorkerContext.location; @docsEditable true
   final WorkerLocation location;
@@ skipping 50 matching lines @@
   FileSystemSync webkitRequestFileSystemSync(int type, int size) native;
 
   /// @domName WorkerContext.webkitResolveLocalFileSystemSyncURL; @docsEditable true
   @JSName('webkitResolveLocalFileSystemSyncURL')
   EntrySync webkitResolveLocalFileSystemSyncUrl(String url) native;
 
   /// @domName WorkerContext.webkitResolveLocalFileSystemURL; @docsEditable true
   @JSName('webkitResolveLocalFileSystemURL')
   void webkitResolveLocalFileSystemUrl(String url, EntryCallback successCallback, [ErrorCallback errorCallback]) native;
 
+  Stream<Event> get onError => errorEvent.forTarget(this);
+
 
   /**
    * Gets an instance of the Indexed DB factory to being using Indexed DB.
    *
    * Use [IdbFactory.supported] to check if Indexed DB is supported on the
    * current platform.
    */
   @SupportedBrowser(SupportedBrowser.CHROME, '23.0')
   @SupportedBrowser(SupportedBrowser.FIREFOX, '15.0')
   @SupportedBrowser(SupportedBrowser.IE, '10.0')
@@ skipping 2350 matching lines @@
    * Determines if the current device is running WebKit.
    */
   static bool get isWebKit => !isOpera && userAgent.contains("WebKit", 0);
 }
 // Copyright (c) 2011, 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.
 
 
 typedef void EventListener(Event event);
+// 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.
+
+
+/**
+ * Adapter for exposing DOM events as Dart streams.
+ */
+class _EventStream<T extends Event> extends Stream<T> {
+  final EventTarget _target;
+  final String _eventType;
+  final bool _useCapture;
+
+  _EventStream(this._target, this._eventType, this._useCapture);
+
+  // DOM events are inherently multi-subscribers.
+  Stream<T> asMultiSubscriberStream() => this;
+
+  StreamSubscription<T> listen(void onData(T event),
+      { void onError(AsyncError error),
+      void onDone(),
+      bool unsubscribeOnError}) {
+
+    return new _EventStreamSubscription<T>(
+        this._target, this._eventType, onData, this._useCapture);
+  }
+}
+
+class _EventStreamSubscription<T extends Event> extends StreamSubscription<T> {
+  int _pauseCount = 0;
+  EventTarget _target;
+  final String _eventType;
+  var _onData;
+  final bool _useCapture;
+
+  _EventStreamSubscription(this._target, this._eventType, this._onData,
+      this._useCapture) {
+    _tryResume();
+  }
+
+  void cancel() {
+    if (_canceled) {
+      throw new StateError("Subscription has been canceled.");
+    }
+
+    _unlisten();
+    // Clear out the target to indicate this is complete.
+    _target = null;
+    _onData = null;
+  }
+
+  bool get _canceled => _target == null;
+
+  void onData(void handleData(T event)) {
+    if (_canceled) {
+      throw new StateError("Subscription has been canceled.");
+    }
+    // Remove current event listener.
+    _unlisten();
+
+    _onData = handleData;
+    _tryResume();
+  }
+
+  /// Has no effect.
+  void onError(void handleError(AsyncError error)) {}
+
+  /// Has no effect.
+  void onDone(void handleDone()) {}
+
+  void pause([Future resumeSignal]) {
+    if (_canceled) {
+      throw new StateError("Subscription has been canceled.");
+    }
+    ++_pauseCount;
+    _unlisten();
+
+    if (resumeSignal != null) {
+      resumeSignal.whenComplete(resume);
+    }
+  }
+
+  bool get _paused => _pauseCount > 0;
+
+  void resume() {
+    if (_canceled) {
+      throw new StateError("Subscription has been canceled.");
+    }
+    if (!_paused) {
+      throw new StateError("Subscription is not paused.");
+    }
+    --_pauseCount;
+    _tryResume();
+  }
+
+  void _tryResume() {
+    if (_onData != null && !_paused) {
+      _target.$dom_addEventListener(_eventType, _onData, _useCapture);
+    }
+  }
+
+  void _unlisten() {
+    if (_onData != null) {
+      _target.$dom_removeEventListener(_eventType, _onData, _useCapture);
+    }
+  }
+}
+
+
+/**
+ * A factory to expose DOM events as Streams.
+ */
+class EventStreamProvider<T extends Event> {
+  final String _eventType;
+
+  const EventStreamProvider(this._eventType);
+
+  /**
+   * Gets a [Stream] for this event type, on the specified target.
+   *
+   * This may be used to capture DOM events:
+   *
+   *     Element.keyDownEvent.forTarget(element, useCapture: true).listen(...);
+   *
+   * Or for listening to an event which will bubble through the DOM tree:
+   *
+   *     MediaElement.pauseEvent.forTarget(document.body).listen(...);
+   *
+   * See also:
+   *
+   * [addEventListener](http://docs.webplatform.org/wiki/dom/methods/addEventListener)
+   */
+  Stream<T> forTarget(EventTarget e, {bool useCapture: false}) {
+    return new _EventStream(e, _eventType, useCapture);
+  }
+}
 // Copyright (c) 2012, 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.
 
 
 /**
  * Works with KeyboardEvent and KeyEvent to determine how to expose information
  * about Key(board)Events. This class functions like an EventListenerList, and
  * provides a consistent interface for the Dart
  * user, despite the fact that a multitude of browsers that have varying
@@ skipping 2515 matching lines @@
       _position = nextPosition;
       return true;
     }
     _current = null;
     _position = _array.length;
     return false;
   }
 
   T get current => _current;
 }