Fixing FrozenElementList Iterator

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 759 matching lines @@
 
   /// The height of this canvas element in CSS pixels.
   /// @domName HTMLCanvasElement.height; @docsEditable true
   int height;
 
   /// The width of this canvas element in CSS pixels.
   /// @domName HTMLCanvasElement.width; @docsEditable true
   int width;
 
   /**
-   * Returns a data URI containing a representation of the image in the 
-   * format specified by type (defaults to 'image/png'). 
-   * 
+   * Returns a data URI containing a representation of the image in the
+   * format specified by type (defaults to 'image/png').
+   *
    * Data Uri format is as follow `data:[<MIME-type>][;charset=<encoding>][;base64],<data>`
-   * 
+   *
    * Optional parameter [quality] in the range of 0.0 and 1.0 can be used when requesting [type]
    * 'image/jpeg' or 'image/webp'. If [quality] is not passed the default
    * value is used. Note: the default value varies by browser.
-   * 
+   *
    * If the height or width of this canvas element is 0, then 'data:' is returned,
    * representing no data.
-   * 
-   * If the type requested is not 'image/png', and the returned value is 
+   *
+   * If the type requested is not 'image/png', and the returned value is
    * 'data:image/png', then the requested type is not supported.
-   * 
+   *
    * Example usage:
-   * 
+   *
    *     CanvasElement canvas = new CanvasElement();
    *     var ctx = canvas.context2d
    *     ..fillStyle = "rgb(200,0,0)"
    *     ..fillRect(10, 10, 55, 50);
    *     var dataUrl = canvas.toDataURL("image/jpeg", 0.95);
    *     // The Data Uri would look similar to
    *     // 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUA
    *     // AAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO
    *     // 9TXL0Y4OHwAAAABJRU5ErkJggg=='
    *     //Create a new image element from the data URI.
    *     var img = new ImageElement();
    *     img.src = dataUrl;
    *     document.body.children.add(img);
-   *     
+   *
    * See also:
-   * 
+   *
    * * [Data URI Scheme](http://en.wikipedia.org/wiki/Data_URI_scheme) from Wikipedia.
-   * 
+   *
    * * [HTMLCanvasElement](https://developer.mozilla.org/en-US/docs/DOM/HTMLCanvasElement) from MDN.
-   * 
+   *
    * * [toDataUrl](http://dev.w3.org/html5/spec/the-canvas-element.html#dom-canvas-todataurl) from W3C.
    */
   /// @domName HTMLCanvasElement.toDataURL; @docsEditable true
   @JSName('toDataURL')
   String toDataUrl(String type, [num quality]) native;
 
 
   CanvasRenderingContext getContext(String contextId) native;
   CanvasRenderingContext2D get context2d => getContext('2d');
 }
@@ skipping 6687 matching lines @@
     return _Collections.minInList(this, compare);
   }
 
   Element max([int compare(Element a, Element b)]) {
     return _Collections.maxInList(this, compare);
   }
 }
 
 class _FrozenElementListIterator implements Iterator<Element> {
   final _FrozenElementList _list;
-  int _index = 0;
+  int _index = -1;
   Element _current;
 
   _FrozenElementListIterator(this._list);
 
   /**
    * Moves to the next element. Returns true if the iterator is positioned
    * at an element. Returns false if it is positioned after the last element.
    */
   bool moveNext() {
     int nextIndex = _index + 1;
@@ skipping 1248 matching lines @@
 // 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.
 
 
 /**
  * Base class that supports listening for and dispatching browser events.
  *
  * Events can either be accessed by string name (using the indexed getter) or by
  * getters exposed by subclasses. Use the getters exposed by subclasses when
  * possible for better compile-time type checks.
- * 
+ *
  * Using an indexed getter:
  *     events['mouseover'].add((e) => print("Mouse over!"));
  *
  * Using a getter provided by a subclass:
  *     elementEvents.mouseOver.add((e) => print("Mouse over!"));
  */
 class Events {
   /* Raw event target. */
   final EventTarget _ptr;
 
@@ skipping 42 matching lines @@
 }
 
 /// @domName EventTarget
 /**
  * Base class for all browser objects that support events.
  *
  * Use the [on] property to add, remove, and dispatch events (rather than
  * [$dom_addEventListener], [$dom_dispatchEvent], and
  * [$dom_removeEventListener]) for compile-time type checks and a more concise
  * API.
- */ 
+ */
 class EventTarget native "*EventTarget" {
 
   /** @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent */
   Events get on => new Events(this);
 
   /// @domName EventTarget.addEventListener; @docsEditable true
   @JSName('addEventListener')
   void $dom_addEventListener(String type, EventListener listener, [bool useCapture]) native;
 
   /// @domName EventTarget.dispatchEvent; @docsEditable true
@@ skipping 610 matching lines @@
 
 /// @domName Float32Array; @docsEditable true
 class Float32Array extends ArrayBufferView implements JavaScriptIndexingBehavior, List<num> native "*Float32Array" {
 
   factory Float32Array(int length) =>
     _TypedArrayFactoryProvider.createFloat32Array(length);
 
   factory Float32Array.fromList(List<num> list) =>
     _TypedArrayFactoryProvider.createFloat32Array_fromList(list);
 
-  factory Float32Array.fromBuffer(ArrayBuffer buffer, [int byteOffset, int length]) => 
+  factory Float32Array.fromBuffer(ArrayBuffer buffer, [int byteOffset, int length]) =>
     _TypedArrayFactoryProvider.createFloat32Array_fromBuffer(buffer, byteOffset, length);
 
   static const int BYTES_PER_ELEMENT = 4;
 
   /// @domName Float32Array.length; @docsEditable true
   int get length => JS("int", "#.length", this);
 
   num operator[](int index) => JS("num", "#[#]", this, index);
 
   void operator[]=(int index, num value) { JS("void", "#[#] = #", this, index, value); }  // -- start List<num> mixins.
@@ skipping 150 matching lines @@
 
 /// @domName Float64Array; @docsEditable true
 class Float64Array extends ArrayBufferView implements JavaScriptIndexingBehavior, List<num> native "*Float64Array" {
 
   factory Float64Array(int length) =>
     _TypedArrayFactoryProvider.createFloat64Array(length);
 
   factory Float64Array.fromList(List<num> list) =>
     _TypedArrayFactoryProvider.createFloat64Array_fromList(list);
 
-  factory Float64Array.fromBuffer(ArrayBuffer buffer, [int byteOffset, int length]) => 
+  factory Float64Array.fromBuffer(ArrayBuffer buffer, [int byteOffset, int length]) =>
     _TypedArrayFactoryProvider.createFloat64Array_fromBuffer(buffer, byteOffset, length);
 
   static const int BYTES_PER_ELEMENT = 8;
 
   /// @domName Float64Array.length; @docsEditable true
   int get length => JS("int", "#.length", this);
 
   num operator[](int index) => JS("num", "#[#]", this, index);
 
   void operator[]=(int index, num value) { JS("void", "#[#] = #", this, index, value); }  // -- start List<num> mixins.
@@ skipping 987 matching lines @@
   /// @domName HTMLOptionsCollection.remove; @docsEditable true
   void remove(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.
 
 
 /**
  * A utility for retrieving data from a URL.
- * 
+ *
  * HttpRequest can be used to obtain data from http, ftp, and file
- * protocols. 
- * 
+ * protocols.
+ *
  * For example, suppose we're developing these API docs, and we
  * wish to retrieve the HTML of the top-level page and print it out.
  * The easiest way to do that would be:
- * 
+ *
  *     var httpRequest = HttpRequest.get('http://api.dartlang.org',
  *         (request) => print(request.responseText));
- * 
+ *
  * **Important**: With the default behavior of this class, your
  * code making the request should be served from the same origin (domain name,
  * port, and application layer protocol) as the URL you are trying to access
- * with HttpRequest. However, there are ways to 
+ * with HttpRequest. However, there are ways to
  * [get around this restriction](http://www.dartlang.org/articles/json-web-service/#note-on-jsonp).
- * 
+ *
  * See also:
  *
  * * [Dart article on using HttpRequests](http://www.dartlang.org/articles/json-web-service/#getting-data)
  * * [JS XMLHttpRequest](https://developer.mozilla.org/en-US/docs/DOM/XMLHttpRequest)
  * * [Using XMLHttpRequest](https://developer.mozilla.org/en-US/docs/DOM/XMLHttpRequest/Using_XMLHttpRequest)
  */
 /// @domName XMLHttpRequest
 class HttpRequest extends EventTarget native "*XMLHttpRequest" {
   /**
    * Creates a URL get request for the specified `url`.
-   * 
+   *
    * After completing the request, the object will call the user-provided
    * [onComplete] callback.
    */
   factory HttpRequest.get(String url, onComplete(HttpRequest request)) =>
       _HttpRequestUtils.get(url, onComplete, false);
 
   // 80 char issue for comments in lists: dartbug.com/7588.
   /**
    * Creates a URL GET request for the specified `url` with
    * credentials such a cookie (already) set in the header or
    * [authorization headers](http://tools.ietf.org/html/rfc1945#section-10.2).
-   * 
-   * After completing the request, the object will call the user-provided 
+   *
+   * After completing the request, the object will call the user-provided
    * [onComplete] callback.
    *
    * A few other details to keep in mind when using credentials:
    *
    * * Using credentials is only useful for cross-origin requests.
    * * The `Access-Control-Allow-Origin` header of `url` cannot contain a wildcard (*).
    * * 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);
 
 
   ///@docsEditable true
   factory HttpRequest() => HttpRequest._create();
   static HttpRequest _create() => JS('HttpRequest', 'new XMLHttpRequest()');
@@ skipping 49 matching lines @@
    *   </tr>
    * </table>
    */
   /// @domName XMLHttpRequest.readyState; @docsEditable true
   final int readyState;
 
   /**
    * The data received as a reponse from the request.
    *
    * The data could be in the
-   * form of a [String], [ArrayBuffer], [Document], [Blob], or json (also a 
+   * form of a [String], [ArrayBuffer], [Document], [Blob], or json (also a
    * [String]). `null` indicates request failure.
    */
   /// @domName XMLHttpRequest.response; @docsEditable true
   @Creates('ArrayBuffer|Blob|Document|=Object|=List|String|num')
   final Object response;
 
   /**
    * The response in string form or null on failure.
    */
   /// @domName XMLHttpRequest.responseText; @docsEditable true
   final String responseText;
 
   /**
-   * [String] telling the server the desired response format. 
+   * [String] telling the server the desired response format.
    *
    * Default is `String`.
    * Other options are one of 'arraybuffer', 'blob', 'document', 'json',
    * 'text'. Some newer browsers will throw `NS_ERROR_DOM_INVALID_ACCESS_ERR` if
    * `responseType` is set while performing a synchronous request.
    *
    * See also: [MDN responseType](https://developer.mozilla.org/en-US/docs/DOM/XMLHttpRequest#responseType)
    */
   /// @domName XMLHttpRequest.responseType; @docsEditable true
   String responseType;
 
   /**
    * The request response, or null on failure.
-   * 
+   *
    * The response is processed as
    * `text/xml` stream, unless responseType = 'document' and the request is
    * synchronous.
    */
   /// @domName XMLHttpRequest.responseXML; @docsEditable true
   @JSName('responseXML')
   final Document responseXml;
 
   /**
    * The http result code from the request (200, 404, etc).
@@ skipping 11 matching lines @@
 
   /**
    * [EventTarget] that can hold listeners to track the progress of the request.
    * The events fired will be members of [HttpRequestUploadEvents].
    */
   /// @domName XMLHttpRequest.upload; @docsEditable true
   final HttpRequestUpload upload;
 
   /**
    * True if cross-site requests should use credentials such as cookies
-   * or authorization headers; false otherwise. 
+   * or authorization headers; false otherwise.
    *
    * This value is ignored for same-site requests.
    */
   /// @domName XMLHttpRequest.withCredentials; @docsEditable true
   bool withCredentials;
 
   /**
    * Stop the current request.
    *
-   * The request can only be stopped if readyState is `HEADERS_RECIEVED` or 
+   * The request can only be stopped if readyState is `HEADERS_RECIEVED` or
    * `LOADING`. If this method is not in the process of being sent, the method
    * has no effect.
    */
   /// @domName XMLHttpRequest.abort; @docsEditable true
   void abort() native;
 
   /// @domName XMLHttpRequest.addEventListener; @docsEditable true
   @JSName('addEventListener')
   void $dom_addEventListener(String type, EventListener listener, [bool useCapture]) native;
 
   /// @domName XMLHttpRequest.dispatchEvent; @docsEditable true
   @JSName('dispatchEvent')
   bool $dom_dispatchEvent(Event evt) native;
 
   /**
    * Retrieve all the response headers from a request.
-   * 
+   *
    * `null` if no headers have been received. For multipart requests,
    * `getAllResponseHeaders` will return the response headers for the current
    * part of the request.
-   * 
+   *
    * See also [HTTP response headers](http://en.wikipedia.org/wiki/List_of_HTTP_header_fields#Responses)
    * for a list of common response headers.
    */
   /// @domName XMLHttpRequest.getAllResponseHeaders; @docsEditable true
   String getAllResponseHeaders() native;
 
   /**
    * Return the response header named `header`, or `null` if not found.
-   * 
+   *
    * See also [HTTP response headers](http://en.wikipedia.org/wiki/List_of_HTTP_header_fields#Responses)
    * for a list of common response headers.
    */
   /// @domName XMLHttpRequest.getResponseHeader; @docsEditable true
   String getResponseHeader(String header) native;
 
   /**
    * Specify the desired `url`, and `method` to use in making the request.
-   * 
+   *
    * By default the request is done asyncronously, with no user or password
    * authentication information. If `async` is false, the request will be send
    * synchronously.
-   * 
+   *
    * Calling `open` again on a currently active request is equivalent to
    * calling `abort`.
    */
   /// @domName XMLHttpRequest.open; @docsEditable true
   void open(String method, String url, [bool async, String user, String password]) native;
 
   /**
    * Specify a particular MIME type (such as `text/xml`) desired for the
    * response.
-   * 
+   *
    * This value must be set before the request has been sent. See also the list
    * of [common MIME types](http://en.wikipedia.org/wiki/Internet_media_type#List_of_common_media_types)
    */
   /// @domName XMLHttpRequest.overrideMimeType; @docsEditable true
   void overrideMimeType(String override) native;
 
   /// @domName XMLHttpRequest.removeEventListener; @docsEditable true
   @JSName('removeEventListener')
   void $dom_removeEventListener(String type, EventListener listener, [bool useCapture]) native;
 
   /**
    * Send the request with any given `data`.
    *
-   * See also: 
+   * See also:
    * [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;
 
 }
 
 /**
  * A class that supports listening for and dispatching events that can fire when
- * making an HTTP request. 
- *  
+ * 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));
  *
  * Each property of this class is a read-only pointer to an [EventListenerList].
  * That list holds all of the [EventListener]s that have registered for that
  * particular type of event that fires from an HttpRequest.
  */
 /// @docsEditable true
 class HttpRequestEvents extends Events {
   /// @docsEditable true
   HttpRequestEvents(EventTarget _ptr) : super(_ptr);
@@ skipping 27 matching lines @@
   EventListenerList get loadEnd => this['loadend'];
 
   /**
    * Event listeners to be notified when the request starts, once
    * `httpRequest.send()` has been called.
    */
   /// @docsEditable true
   EventListenerList get loadStart => this['loadstart'];
 
   /**
-   * Event listeners to be notified when data for the request 
+   * Event listeners to be notified when data for the request
    * is being sent or loaded.
    *
    * Progress events are fired every 50ms or for every byte transmitted,
    * whichever is less frequent.
    */
   /// @docsEditable true
   EventListenerList get progress => this['progress'];
 
   /**
    * Event listeners to be notified every time the [HttpRequest]
@@ skipping 1016 matching lines @@
 
 /// @domName Int16Array; @docsEditable true
 class Int16Array extends ArrayBufferView implements JavaScriptIndexingBehavior, List<int> native "*Int16Array" {
 
   factory Int16Array(int length) =>
     _TypedArrayFactoryProvider.createInt16Array(length);
 
   factory Int16Array.fromList(List<int> list) =>
     _TypedArrayFactoryProvider.createInt16Array_fromList(list);
 
-  factory Int16Array.fromBuffer(ArrayBuffer buffer, [int byteOffset, int length]) => 
+  factory Int16Array.fromBuffer(ArrayBuffer buffer, [int byteOffset, int length]) =>
     _TypedArrayFactoryProvider.createInt16Array_fromBuffer(buffer, byteOffset, length);
 
   static const int BYTES_PER_ELEMENT = 2;
 
   /// @domName Int16Array.length; @docsEditable true
   int get length => JS("int", "#.length", this);
 
   int operator[](int index) => JS("int", "#[#]", this, index);
 
   void operator[]=(int index, int value) { JS("void", "#[#] = #", this, index, value); }  // -- start List<int> mixins.
@@ skipping 150 matching lines @@
 
 /// @domName Int32Array; @docsEditable true
 class Int32Array extends ArrayBufferView implements JavaScriptIndexingBehavior, List<int> native "*Int32Array" {
 
   factory Int32Array(int length) =>
     _TypedArrayFactoryProvider.createInt32Array(length);
 
   factory Int32Array.fromList(List<int> list) =>
     _TypedArrayFactoryProvider.createInt32Array_fromList(list);
 
-  factory Int32Array.fromBuffer(ArrayBuffer buffer, [int byteOffset, int length]) => 
+  factory Int32Array.fromBuffer(ArrayBuffer buffer, [int byteOffset, int length]) =>
     _TypedArrayFactoryProvider.createInt32Array_fromBuffer(buffer, byteOffset, length);
 
   static const int BYTES_PER_ELEMENT = 4;
 
   /// @domName Int32Array.length; @docsEditable true
   int get length => JS("int", "#.length", this);
 
   int operator[](int index) => JS("int", "#[#]", this, index);
 
   void operator[]=(int index, int value) { JS("void", "#[#] = #", this, index, value); }  // -- start List<int> mixins.
@@ skipping 150 matching lines @@
 
 /// @domName Int8Array; @docsEditable true
 class Int8Array extends ArrayBufferView implements JavaScriptIndexingBehavior, List<int> native "*Int8Array" {
 
   factory Int8Array(int length) =>
     _TypedArrayFactoryProvider.createInt8Array(length);
 
   factory Int8Array.fromList(List<int> list) =>
     _TypedArrayFactoryProvider.createInt8Array_fromList(list);
 
-  factory Int8Array.fromBuffer(ArrayBuffer buffer, [int byteOffset, int length]) => 
+  factory Int8Array.fromBuffer(ArrayBuffer buffer, [int byteOffset, int length]) =>
     _TypedArrayFactoryProvider.createInt8Array_fromBuffer(buffer, byteOffset, length);
 
   static const int BYTES_PER_ELEMENT = 1;
 
   /// @domName Int8Array.length; @docsEditable true
   int get length => JS("int", "#.length", this);
 
   int operator[](int index) => JS("int", "#[#]", this, index);
 
   void operator[]=(int index, int value) { JS("void", "#[#] = #", this, index, value); }  // -- start List<int> mixins.
@@ skipping 1910 matching lines @@
 // 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 Navigator; @docsEditable true
 class Navigator native "*Navigator" {
 
   /// @domName Navigator.language; @docsEditable true
   String get language => JS('String', '#.language || #.userLanguage', this,
       this);
-  
+
   /// @domName Navigator.appCodeName; @docsEditable true
   final String appCodeName;
 
   /// @domName Navigator.appName; @docsEditable true
   final String appName;
 
   /// @domName Navigator.appVersion; @docsEditable true
   final String appVersion;
 
   /// @domName Navigator.cookieEnabled; @docsEditable true
@@ skipping 4704 matching lines @@
 
 /// @domName Uint16Array; @docsEditable true
 class Uint16Array extends ArrayBufferView implements JavaScriptIndexingBehavior, List<int> native "*Uint16Array" {
 
   factory Uint16Array(int length) =>
     _TypedArrayFactoryProvider.createUint16Array(length);
 
   factory Uint16Array.fromList(List<int> list) =>
     _TypedArrayFactoryProvider.createUint16Array_fromList(list);
 
-  factory Uint16Array.fromBuffer(ArrayBuffer buffer, [int byteOffset, int length]) => 
+  factory Uint16Array.fromBuffer(ArrayBuffer buffer, [int byteOffset, int length]) =>
     _TypedArrayFactoryProvider.createUint16Array_fromBuffer(buffer, byteOffset, length);
 
   static const int BYTES_PER_ELEMENT = 2;
 
   /// @domName Uint16Array.length; @docsEditable true
   int get length => JS("int", "#.length", this);
 
   int operator[](int index) => JS("int", "#[#]", this, index);
 
   void operator[]=(int index, int value) { JS("void", "#[#] = #", this, index, value); }  // -- start List<int> mixins.
@@ skipping 150 matching lines @@
 
 /// @domName Uint32Array; @docsEditable true
 class Uint32Array extends ArrayBufferView implements JavaScriptIndexingBehavior, List<int> native "*Uint32Array" {
 
   factory Uint32Array(int length) =>
     _TypedArrayFactoryProvider.createUint32Array(length);
 
   factory Uint32Array.fromList(List<int> list) =>
     _TypedArrayFactoryProvider.createUint32Array_fromList(list);
 
-  factory Uint32Array.fromBuffer(ArrayBuffer buffer, [int byteOffset, int length]) => 
+  factory Uint32Array.fromBuffer(ArrayBuffer buffer, [int byteOffset, int length]) =>
     _TypedArrayFactoryProvider.createUint32Array_fromBuffer(buffer, byteOffset, length);
 
   static const int BYTES_PER_ELEMENT = 4;
 
   /// @domName Uint32Array.length; @docsEditable true
   int get length => JS("int", "#.length", this);
 
   int operator[](int index) => JS("int", "#[#]", this, index);
 
   void operator[]=(int index, int value) { JS("void", "#[#] = #", this, index, value); }  // -- start List<int> mixins.
@@ skipping 150 matching lines @@
 
 /// @domName Uint8Array; @docsEditable true
 class Uint8Array extends ArrayBufferView implements JavaScriptIndexingBehavior, List<int> native "*Uint8Array" {
 
   factory Uint8Array(int length) =>
     _TypedArrayFactoryProvider.createUint8Array(length);
 
   factory Uint8Array.fromList(List<int> list) =>
     _TypedArrayFactoryProvider.createUint8Array_fromList(list);
 
-  factory Uint8Array.fromBuffer(ArrayBuffer buffer, [int byteOffset, int length]) => 
+  factory Uint8Array.fromBuffer(ArrayBuffer buffer, [int byteOffset, int length]) =>
     _TypedArrayFactoryProvider.createUint8Array_fromBuffer(buffer, byteOffset, length);
 
   static const int BYTES_PER_ELEMENT = 1;
 
   /// @domName Uint8Array.length; @docsEditable true
   int get length => JS("int", "#.length", this);
 
   int operator[](int index) => JS("int", "#[#]", this, index);
 
   void operator[]=(int index, int value) { JS("void", "#[#] = #", this, index, value); }  // -- start List<int> mixins.
@@ skipping 150 matching lines @@
 
 /// @domName Uint8ClampedArray; @docsEditable true
 class Uint8ClampedArray extends Uint8Array native "*Uint8ClampedArray" {
 
   factory Uint8ClampedArray(int length) =>
     _TypedArrayFactoryProvider.createUint8ClampedArray(length);
 
   factory Uint8ClampedArray.fromList(List<int> list) =>
     _TypedArrayFactoryProvider.createUint8ClampedArray_fromList(list);
 
-  factory Uint8ClampedArray.fromBuffer(ArrayBuffer buffer, [int byteOffset, int length]) => 
+  factory Uint8ClampedArray.fromBuffer(ArrayBuffer buffer, [int byteOffset, int length]) =>
     _TypedArrayFactoryProvider.createUint8ClampedArray_fromBuffer(buffer, byteOffset, length);
 
   // Use implementation from Uint8Array.
   // final int length;
 
   /// @domName Uint8ClampedArray.setElements; @docsEditable true
   @JSName('set')
   void setElements(Object array, [int offset]) native;
 
   /// @domName Uint8ClampedArray.subarray; @docsEditable true
@@ skipping 5243 matching lines @@
     }
     _dispatch(e);
   }
 }
 // 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.
 
 
 /**
- * Defines the keycode values for keys that are returned by 
+ * Defines the keycode values for keys that are returned by
  * KeyboardEvent.keyCode.
- * 
+ *
  * Important note: There is substantial divergence in how different browsers
  * handle keycodes and their variants in different locales/keyboard layouts. We
  * provide these constants to help make code processing keys more readable.
  */
 abstract class KeyCode {
   // These constant names were borrowed from Closure's Keycode enumeration
   // class.
-  // http://closure-library.googlecode.com/svn/docs/closure_goog_events_keycodes.js.source.html  
+  // http://closure-library.googlecode.com/svn/docs/closure_goog_events_keycodes.js.source.html
   static const int WIN_KEY_FF_LINUX = 0;
   static const int MAC_ENTER = 3;
   static const int BACKSPACE = 8;
   static const int TAB = 9;
   /** NUM_CENTER is also NUMLOCK for FF and Safari on Mac. */
   static const int NUM_CENTER = 12;
   static const int ENTER = 13;
   static const int SHIFT = 16;
   static const int CTRL = 17;
   static const int ALT = 18;
@@ skipping 174 matching lines @@
    * Returns true if the keyCode produces a (US keyboard) character.
    * Note: This does not (yet) cover characters on non-US keyboards (Russian,
    * Hebrew, etc.).
    */
   static bool isCharacterKey(int keyCode) {
     if ((keyCode >= ZERO && keyCode <= NINE) ||
         (keyCode >= NUM_ZERO && keyCode <= NUM_MULTIPLY) ||
         (keyCode >= A && keyCode <= Z)) {
       return true;
     }
- 
+
     // Safari sends zero key code for non-latin characters.
     if (_Device.isWebKit && keyCode == 0) {
       return true;
     }
- 
+
     return (keyCode == SPACE || keyCode == QUESTION_MARK || keyCode == NUM_PLUS
         || keyCode == NUM_MINUS || keyCode == NUM_PERIOD ||
         keyCode == NUM_DIVISION || keyCode == SEMICOLON ||
         keyCode == FF_SEMICOLON || keyCode == DASH || keyCode == EQUALS ||
         keyCode == FF_EQUALS || keyCode == COMMA || keyCode == PERIOD ||
         keyCode == SLASH || keyCode == APOSTROPHE || keyCode == SINGLE_QUOTE ||
         keyCode == OPEN_SQUARE_BRACKET || keyCode == BACKSLASH ||
         keyCode == CLOSE_SQUARE_BRACKET);
   }
 }
@@ skipping 1848 matching lines @@
 // 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.
 
 
 // Iterator for arrays with fixed size.
 class FixedSizeListIterator<T> implements Iterator<T> {
   final List<T> _array;
   final int _length;  // Cache array length for faster access.
   int _position;
   T _current;
-  
+
   FixedSizeListIterator(List<T> array)
       : _array = array,
         _position = -1,
         _length = array.length;
 
   bool moveNext() {
     int nextPosition = _position + 1;
     if (nextPosition < _length) {
       _current = _array[nextPosition];
       _position = nextPosition;
@@ skipping 24 matching lines @@
       _position = nextPosition;
       return true;
     }
     _current = null;
     _position = _array.length;
     return false;
   }
 
   T get current => _current;
 }