Unbreak pub:

sdk/lib/svg/dart2js/svg_dart2js.dart

 library dart.dom.svg;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:html';
 import 'dart:html_common';
 import 'dart:_js_helper' show Creates, Returns, JavaScriptIndexingBehavior, JSName;
 import 'dart:_foreign_helper' show JS;
 // DO NOT EDIT
 // Auto-generated dart:svg library.
@@ skipping 3064 matching lines @@
   bool contains(Length element) => IterableMixinWorkaround.contains(this, element);
 
   void forEach(void f(Length element)) => IterableMixinWorkaround.forEach(this, f);
 
   String join([String separator]) =>
       IterableMixinWorkaround.joinList(this, separator);
 
   Iterable map(f(Length element)) =>
       IterableMixinWorkaround.mapList(this, f);
 
+  List mappedBy(f(Length element)) =>
+      IterableMixinWorkaround.mappedByList(this, f);
+
   Iterable<Length> where(bool f(Length element)) =>
       IterableMixinWorkaround.where(this, f);
 
   Iterable expand(Iterable f(Length element)) =>
       IterableMixinWorkaround.expand(this, f);
 
   bool every(bool f(Length element)) => IterableMixinWorkaround.every(this, f);
 
   bool any(bool f(Length element)) => IterableMixinWorkaround.any(this, f);
 
@@ skipping 44 matching lines @@
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   // From List<Length>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   // clear() defined by IDL.
 
-  Iterable<Length> get reversed {
+  List<Length> get reversed {
     return IterableMixinWorkaround.reversedList(this);
   }
 
   void sort([int compare(Length a, Length b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(Length element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
@@ skipping 539 matching lines @@
   bool contains(Number element) => IterableMixinWorkaround.contains(this, element);
 
   void forEach(void f(Number element)) => IterableMixinWorkaround.forEach(this, f);
 
   String join([String separator]) =>
       IterableMixinWorkaround.joinList(this, separator);
 
   Iterable map(f(Number element)) =>
       IterableMixinWorkaround.mapList(this, f);
 
+  List mappedBy(f(Number element)) =>
+      IterableMixinWorkaround.mappedByList(this, f);
+
   Iterable<Number> where(bool f(Number element)) =>
       IterableMixinWorkaround.where(this, f);
 
   Iterable expand(Iterable f(Number element)) =>
       IterableMixinWorkaround.expand(this, f);
 
   bool every(bool f(Number element)) => IterableMixinWorkaround.every(this, f);
 
   bool any(bool f(Number element)) => IterableMixinWorkaround.any(this, f);
 
@@ skipping 44 matching lines @@
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   // From List<Number>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   // clear() defined by IDL.
 
-  Iterable<Number> get reversed {
+  List<Number> get reversed {
     return IterableMixinWorkaround.reversedList(this);
   }
 
   void sort([int compare(Number a, Number b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(Number element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
@@ skipping 815 matching lines @@
   bool contains(PathSeg element) => IterableMixinWorkaround.contains(this, element);
 
   void forEach(void f(PathSeg element)) => IterableMixinWorkaround.forEach(this, f);
 
   String join([String separator]) =>
       IterableMixinWorkaround.joinList(this, separator);
 
   Iterable map(f(PathSeg element)) =>
       IterableMixinWorkaround.mapList(this, f);
 
+  List mappedBy(f(PathSeg element)) =>
+      IterableMixinWorkaround.mappedByList(this, f);
+
   Iterable<PathSeg> where(bool f(PathSeg element)) =>
       IterableMixinWorkaround.where(this, f);
 
   Iterable expand(Iterable f(PathSeg element)) =>
       IterableMixinWorkaround.expand(this, f);
 
   bool every(bool f(PathSeg element)) => IterableMixinWorkaround.every(this, f);
 
   bool any(bool f(PathSeg element)) => IterableMixinWorkaround.any(this, f);
 
@@ skipping 44 matching lines @@
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   // From List<PathSeg>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   // clear() defined by IDL.
 
-  Iterable<PathSeg> get reversed {
+  List<PathSeg> get reversed {
     return IterableMixinWorkaround.reversedList(this);
   }
 
   void sort([int compare(PathSeg a, PathSeg b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(PathSeg element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
@@ skipping 799 matching lines @@
   bool contains(String element) => IterableMixinWorkaround.contains(this, element);
 
   void forEach(void f(String element)) => IterableMixinWorkaround.forEach(this, f);
 
   String join([String separator]) =>
       IterableMixinWorkaround.joinList(this, separator);
 
   Iterable map(f(String element)) =>
       IterableMixinWorkaround.mapList(this, f);
 
+  List mappedBy(f(String element)) =>
+      IterableMixinWorkaround.mappedByList(this, f);
+
   Iterable<String> where(bool f(String element)) =>
       IterableMixinWorkaround.where(this, f);
 
   Iterable expand(Iterable f(String element)) =>
       IterableMixinWorkaround.expand(this, f);
 
   bool every(bool f(String element)) => IterableMixinWorkaround.every(this, f);
 
   bool any(bool f(String element)) => IterableMixinWorkaround.any(this, f);
 
@@ skipping 44 matching lines @@
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   // From List<String>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   // clear() defined by IDL.
 
-  Iterable<String> get reversed {
+  List<String> get reversed {
     return IterableMixinWorkaround.reversedList(this);
   }
 
   void sort([int compare(String a, String b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(String element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
@@ skipping 1078 matching lines @@
   bool contains(Transform element) => IterableMixinWorkaround.contains(this, element);
 
   void forEach(void f(Transform element)) => IterableMixinWorkaround.forEach(this, f);
 
   String join([String separator]) =>
       IterableMixinWorkaround.joinList(this, separator);
 
   Iterable map(f(Transform element)) =>
       IterableMixinWorkaround.mapList(this, f);
 
+  List mappedBy(f(Transform element)) =>
+      IterableMixinWorkaround.mappedByList(this, f);
+
   Iterable<Transform> where(bool f(Transform element)) =>
       IterableMixinWorkaround.where(this, f);
 
   Iterable expand(Iterable f(Transform element)) =>
       IterableMixinWorkaround.expand(this, f);
 
   bool every(bool f(Transform element)) => IterableMixinWorkaround.every(this, f);
 
   bool any(bool f(Transform element)) => IterableMixinWorkaround.any(this, f);
 
@@ skipping 44 matching lines @@
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   // From List<Transform>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   // clear() defined by IDL.
 
-  Iterable<Transform> get reversed {
+  List<Transform> get reversed {
     return IterableMixinWorkaround.reversedList(this);
   }
 
   void sort([int compare(Transform a, Transform b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(Transform element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
@@ skipping 432 matching lines @@
   bool contains(ElementInstance element) => IterableMixinWorkaround.contains(this, element);
 
   void forEach(void f(ElementInstance element)) => IterableMixinWorkaround.forEach(this, f);
 
   String join([String separator]) =>
       IterableMixinWorkaround.joinList(this, separator);
 
   Iterable map(f(ElementInstance element)) =>
       IterableMixinWorkaround.mapList(this, f);
 
+  List mappedBy(f(ElementInstance element)) =>
+      IterableMixinWorkaround.mappedByList(this, f);
+
   Iterable<ElementInstance> where(bool f(ElementInstance element)) =>
       IterableMixinWorkaround.where(this, f);
 
   Iterable expand(Iterable f(ElementInstance element)) =>
       IterableMixinWorkaround.expand(this, f);
 
   bool every(bool f(ElementInstance element)) => IterableMixinWorkaround.every(this, f);
 
   bool any(bool f(ElementInstance element)) => IterableMixinWorkaround.any(this, f);
 
@@ skipping 46 matching lines @@
 
   // From List<ElementInstance>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  Iterable<ElementInstance> get reversed {
+  List<ElementInstance> get reversed {
     return IterableMixinWorkaround.reversedList(this);
   }
 
   void sort([int compare(ElementInstance a, ElementInstance b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(ElementInstance element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
@@ skipping 477 matching lines @@
 
 
 @DocsEditable
 @DomName('SVGVKernElement')
 class _SVGVKernElement extends SvgElement native "*SVGVKernElement" {
 
   @DomName('SVGVKernElement.SVGVKernElement')
   @DocsEditable
   factory _SVGVKernElement() => _SvgElementFactoryProvider.createSvgElement_tag("vkern");
 }