Creating a common library for all DOM types.

sdk/lib/svg/dartium/svg_dartium.dart

 library svg;
 
 import 'dart:html';
 import 'dart:nativewrappers';
 // DO NOT EDIT
 // Auto-generated dart:svg library.
 
 
 
 
@@ skipping 461 matching lines @@
   }
 
   void addLast(AnimatedLength value) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   void addAll(Collection<AnimatedLength> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
-  bool contains(AnimatedLength element) => _Collections.contains(this, element);
+  bool contains(AnimatedLength element) => Collections.contains(this, element);
 
-  void forEach(void f(AnimatedLength element)) => _Collections.forEach(this, f);
+  void forEach(void f(AnimatedLength element)) => Collections.forEach(this, f);
 
-  Collection map(f(AnimatedLength element)) => _Collections.map(this, [], f);
+  Collection map(f(AnimatedLength element)) => Collections.map(this, [], f);
 
   Collection<AnimatedLength> filter(bool f(AnimatedLength element)) =>
-     _Collections.filter(this, <AnimatedLength>[], f);
+     Collections.filter(this, <AnimatedLength>[], f);
 
-  bool every(bool f(AnimatedLength element)) => _Collections.every(this, f);
+  bool every(bool f(AnimatedLength element)) => Collections.every(this, f);
 
-  bool some(bool f(AnimatedLength element)) => _Collections.some(this, f);
+  bool some(bool f(AnimatedLength element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<AnimatedLength>:
 
   void sort([Comparator<AnimatedLength> compare = Comparable.compare]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(AnimatedLength element, [int start = 0]) =>
@@ skipping 97 matching lines @@
   }
 
   void addLast(AnimatedNumber value) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   void addAll(Collection<AnimatedNumber> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
-  bool contains(AnimatedNumber element) => _Collections.contains(this, element);
+  bool contains(AnimatedNumber element) => Collections.contains(this, element);
 
-  void forEach(void f(AnimatedNumber element)) => _Collections.forEach(this, f);
+  void forEach(void f(AnimatedNumber element)) => Collections.forEach(this, f);
 
-  Collection map(f(AnimatedNumber element)) => _Collections.map(this, [], f);
+  Collection map(f(AnimatedNumber element)) => Collections.map(this, [], f);
 
   Collection<AnimatedNumber> filter(bool f(AnimatedNumber element)) =>
-     _Collections.filter(this, <AnimatedNumber>[], f);
+     Collections.filter(this, <AnimatedNumber>[], f);
 
-  bool every(bool f(AnimatedNumber element)) => _Collections.every(this, f);
+  bool every(bool f(AnimatedNumber element)) => Collections.every(this, f);
 
-  bool some(bool f(AnimatedNumber element)) => _Collections.some(this, f);
+  bool some(bool f(AnimatedNumber element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<AnimatedNumber>:
 
   void sort([Comparator<AnimatedNumber> compare = Comparable.compare]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(AnimatedNumber element, [int start = 0]) =>
@@ skipping 137 matching lines @@
   }
 
   void addLast(AnimateTransformElement value) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   void addAll(Collection<AnimateTransformElement> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
-  bool contains(AnimateTransformElement element) => _Collections.contains(this, element);
+  bool contains(AnimateTransformElement element) => Collections.contains(this, element);
 
-  void forEach(void f(AnimateTransformElement element)) => _Collections.forEach(this, f);
+  void forEach(void f(AnimateTransformElement element)) => Collections.forEach(this, f);
 
-  Collection map(f(AnimateTransformElement element)) => _Collections.map(this, [], f);
+  Collection map(f(AnimateTransformElement element)) => Collections.map(this, [], f);
 
   Collection<AnimateTransformElement> filter(bool f(AnimateTransformElement element)) =>
-     _Collections.filter(this, <AnimateTransformElement>[], f);
+     Collections.filter(this, <AnimateTransformElement>[], f);
 
-  bool every(bool f(AnimateTransformElement element)) => _Collections.every(this, f);
+  bool every(bool f(AnimateTransformElement element)) => Collections.every(this, f);
 
-  bool some(bool f(AnimateTransformElement element)) => _Collections.some(this, f);
+  bool some(bool f(AnimateTransformElement element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<AnimateTransformElement>:
 
   void sort([Comparator<AnimateTransformElement> compare = Comparable.compare]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(AnimateTransformElement element, [int start = 0]) =>
@@ skipping 2949 matching lines @@
   }
 
   void addLast(Length value) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   void addAll(Collection<Length> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
-  bool contains(Length element) => _Collections.contains(this, element);
+  bool contains(Length element) => Collections.contains(this, element);
 
-  void forEach(void f(Length element)) => _Collections.forEach(this, f);
+  void forEach(void f(Length element)) => Collections.forEach(this, f);
 
-  Collection map(f(Length element)) => _Collections.map(this, [], f);
+  Collection map(f(Length element)) => Collections.map(this, [], f);
 
   Collection<Length> filter(bool f(Length element)) =>
-     _Collections.filter(this, <Length>[], f);
+     Collections.filter(this, <Length>[], f);
 
-  bool every(bool f(Length element)) => _Collections.every(this, f);
+  bool every(bool f(Length element)) => Collections.every(this, f);
 
-  bool some(bool f(Length element)) => _Collections.some(this, f);
+  bool some(bool f(Length element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<Length>:
 
   void sort([Comparator<Length> compare = Comparable.compare]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(Length element, [int start = 0]) =>
@@ skipping 627 matching lines @@
   }
 
   void addLast(Number value) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   void addAll(Collection<Number> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
-  bool contains(Number element) => _Collections.contains(this, element);
+  bool contains(Number element) => Collections.contains(this, element);
 
-  void forEach(void f(Number element)) => _Collections.forEach(this, f);
+  void forEach(void f(Number element)) => Collections.forEach(this, f);
 
-  Collection map(f(Number element)) => _Collections.map(this, [], f);
+  Collection map(f(Number element)) => Collections.map(this, [], f);
 
   Collection<Number> filter(bool f(Number element)) =>
-     _Collections.filter(this, <Number>[], f);
+     Collections.filter(this, <Number>[], f);
 
-  bool every(bool f(Number element)) => _Collections.every(this, f);
+  bool every(bool f(Number element)) => Collections.every(this, f);
 
-  bool some(bool f(Number element)) => _Collections.some(this, f);
+  bool some(bool f(Number element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<Number>:
 
   void sort([Comparator<Number> compare = Comparable.compare]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(Number element, [int start = 0]) =>
@@ skipping 1039 matching lines @@
   }
 
   void addLast(PathSeg value) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   void addAll(Collection<PathSeg> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
-  bool contains(PathSeg element) => _Collections.contains(this, element);
+  bool contains(PathSeg element) => Collections.contains(this, element);
 
-  void forEach(void f(PathSeg element)) => _Collections.forEach(this, f);
+  void forEach(void f(PathSeg element)) => Collections.forEach(this, f);
 
-  Collection map(f(PathSeg element)) => _Collections.map(this, [], f);
+  Collection map(f(PathSeg element)) => Collections.map(this, [], f);
 
   Collection<PathSeg> filter(bool f(PathSeg element)) =>
-     _Collections.filter(this, <PathSeg>[], f);
+     Collections.filter(this, <PathSeg>[], f);
 
-  bool every(bool f(PathSeg element)) => _Collections.every(this, f);
+  bool every(bool f(PathSeg element)) => Collections.every(this, f);
 
-  bool some(bool f(PathSeg element)) => _Collections.some(this, f);
+  bool some(bool f(PathSeg element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<PathSeg>:
 
   void sort([Comparator<PathSeg> compare = Comparable.compare]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(PathSeg element, [int start = 0]) =>
@@ skipping 877 matching lines @@
   }
 
   void addLast(String value) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   void addAll(Collection<String> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
-  bool contains(String element) => _Collections.contains(this, element);
+  bool contains(String element) => Collections.contains(this, element);
 
-  void forEach(void f(String element)) => _Collections.forEach(this, f);
+  void forEach(void f(String element)) => Collections.forEach(this, f);
 
-  Collection map(f(String element)) => _Collections.map(this, [], f);
+  Collection map(f(String element)) => Collections.map(this, [], f);
 
   Collection<String> filter(bool f(String element)) =>
-     _Collections.filter(this, <String>[], f);
+     Collections.filter(this, <String>[], f);
 
-  bool every(bool f(String element)) => _Collections.every(this, f);
+  bool every(bool f(String element)) => Collections.every(this, f);
 
-  bool some(bool f(String element)) => _Collections.some(this, f);
+  bool some(bool f(String element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<String>:
 
   void sort([Comparator<String> compare = Comparable.compare]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(String element, [int start = 0]) =>
@@ skipping 1109 matching lines @@
   }
 
   void addLast(Transform value) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   void addAll(Collection<Transform> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
-  bool contains(Transform element) => _Collections.contains(this, element);
+  bool contains(Transform element) => Collections.contains(this, element);
 
-  void forEach(void f(Transform element)) => _Collections.forEach(this, f);
+  void forEach(void f(Transform element)) => Collections.forEach(this, f);
 
-  Collection map(f(Transform element)) => _Collections.map(this, [], f);
+  Collection map(f(Transform element)) => Collections.map(this, [], f);
 
   Collection<Transform> filter(bool f(Transform element)) =>
-     _Collections.filter(this, <Transform>[], f);
+     Collections.filter(this, <Transform>[], f);
 
-  bool every(bool f(Transform element)) => _Collections.every(this, f);
+  bool every(bool f(Transform element)) => Collections.every(this, f);
 
-  bool some(bool f(Transform element)) => _Collections.some(this, f);
+  bool some(bool f(Transform element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<Transform>:
 
   void sort([Comparator<Transform> compare = Comparable.compare]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(Transform element, [int start = 0]) =>
@@ skipping 459 matching lines @@
   }
 
   void addLast(ElementInstance value) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   void addAll(Collection<ElementInstance> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
-  bool contains(ElementInstance element) => _Collections.contains(this, element);
+  bool contains(ElementInstance element) => Collections.contains(this, element);
 
-  void forEach(void f(ElementInstance element)) => _Collections.forEach(this, f);
+  void forEach(void f(ElementInstance element)) => Collections.forEach(this, f);
 
-  Collection map(f(ElementInstance element)) => _Collections.map(this, [], f);
+  Collection map(f(ElementInstance element)) => Collections.map(this, [], f);
 
   Collection<ElementInstance> filter(bool f(ElementInstance element)) =>
-     _Collections.filter(this, <ElementInstance>[], f);
+     Collections.filter(this, <ElementInstance>[], f);
 
-  bool every(bool f(ElementInstance element)) => _Collections.every(this, f);
+  bool every(bool f(ElementInstance element)) => Collections.every(this, f);
 
-  bool some(bool f(ElementInstance element)) => _Collections.some(this, f);
+  bool some(bool f(ElementInstance element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<ElementInstance>:
 
   void sort([Comparator<ElementInstance> compare = Comparable.compare]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(ElementInstance element, [int start = 0]) =>
@@ skipping 27 matching lines @@
   List<ElementInstance> getRange(int start, int rangeLength) =>
       _Lists.getRange(this, start, rangeLength, <ElementInstance>[]);
 
   // -- end List<ElementInstance> mixins.
 
 
   /** @domName SVGElementInstanceList.item */
   ElementInstance item(int index) native "SVGElementInstanceList_item_Callback";
 
 }