Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(157)

Side by Side Diff: sdk/lib/svg/dart2js/svg_dart2js.dart

Issue 12090093: Reapply "Rename mappedBy to map." (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart
Patch Set: Fixed bug in previous commit. Created 7 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
1 library svg; 1 library svg;
2 2
3 import 'dart:async'; 3 import 'dart:async';
4 import 'dart:collection'; 4 import 'dart:collection';
5 import 'dart:html'; 5 import 'dart:html';
6 import 'dart:html_common'; 6 import 'dart:html_common';
7 import 'dart:_js_helper' show Creates, Returns, JavaScriptIndexingBehavior, JSNa me; 7 import 'dart:_js_helper' show Creates, Returns, JavaScriptIndexingBehavior, JSNa me;
8 import 'dart:_foreign_helper' show JS; 8 import 'dart:_foreign_helper' show JS;
9 // DO NOT EDIT 9 // DO NOT EDIT
10 // Auto-generated dart:svg library. 10 // Auto-generated dart:svg library.
(...skipping 3603 matching lines...) Expand 10 before | Expand all | Expand 10 after
3614 return IterableMixinWorkaround.reduce(this, initialValue, combine); 3614 return IterableMixinWorkaround.reduce(this, initialValue, combine);
3615 } 3615 }
3616 3616
3617 bool contains(Length element) => IterableMixinWorkaround.contains(this, elemen t); 3617 bool contains(Length element) => IterableMixinWorkaround.contains(this, elemen t);
3618 3618
3619 void forEach(void f(Length element)) => IterableMixinWorkaround.forEach(this, f); 3619 void forEach(void f(Length element)) => IterableMixinWorkaround.forEach(this, f);
3620 3620
3621 String join([String separator]) => 3621 String join([String separator]) =>
3622 IterableMixinWorkaround.joinList(this, separator); 3622 IterableMixinWorkaround.joinList(this, separator);
3623 3623
3624 List mappedBy(f(Length element)) => IterableMixinWorkaround.mappedByList(this, f); 3624 Iterable map(f(Length element)) =>
3625 IterableMixinWorkaround.map(this, f);
3626
3627 List mappedBy(f(Length element)) =>
3628 IterableMixinWorkaround.mappedByList(this, f);
3625 3629
3626 Iterable<Length> where(bool f(Length element)) => 3630 Iterable<Length> where(bool f(Length element)) =>
3627 IterableMixinWorkaround.where(this, f); 3631 IterableMixinWorkaround.where(this, f);
3628 3632
3629 bool every(bool f(Length element)) => IterableMixinWorkaround.every(this, f); 3633 bool every(bool f(Length element)) => IterableMixinWorkaround.every(this, f);
3630 3634
3631 bool any(bool f(Length element)) => IterableMixinWorkaround.any(this, f); 3635 bool any(bool f(Length element)) => IterableMixinWorkaround.any(this, f);
3632 3636
3633 List<Length> toList() => new List<Length>.from(this); 3637 List<Length> toList() => new List<Length>.from(this);
3634 Set<Length> toSet() => new Set<Length>.from(this); 3638 Set<Length> toSet() => new Set<Length>.from(this);
3635 3639
3636 bool get isEmpty => this.length == 0; 3640 bool get isEmpty => this.length == 0;
3637 3641
3638 List<Length> take(int n) => IterableMixinWorkaround.takeList(this, n); 3642 Iterable<Length> take(int n) => IterableMixinWorkaround.takeList(this, n);
3639 3643
3640 Iterable<Length> takeWhile(bool test(Length value)) { 3644 Iterable<Length> takeWhile(bool test(Length value)) {
3641 return IterableMixinWorkaround.takeWhile(this, test); 3645 return IterableMixinWorkaround.takeWhile(this, test);
3642 } 3646 }
3643 3647
3644 List<Length> skip(int n) => IterableMixinWorkaround.skipList(this, n); 3648 Iterable<Length> skip(int n) => IterableMixinWorkaround.skipList(this, n);
3645 3649
3646 Iterable<Length> skipWhile(bool test(Length value)) { 3650 Iterable<Length> skipWhile(bool test(Length value)) {
3647 return IterableMixinWorkaround.skipWhile(this, test); 3651 return IterableMixinWorkaround.skipWhile(this, test);
3648 } 3652 }
3649 3653
3650 Length firstMatching(bool test(Length value), { Length orElse() }) { 3654 Length firstMatching(bool test(Length value), { Length orElse() }) {
3651 return IterableMixinWorkaround.firstMatching(this, test, orElse); 3655 return IterableMixinWorkaround.firstMatching(this, test, orElse);
3652 } 3656 }
3653 3657
3654 Length lastMatching(bool test(Length value), {Length orElse()}) { 3658 Length lastMatching(bool test(Length value), {Length orElse()}) {
(...skipping 644 matching lines...) Expand 10 before | Expand all | Expand 10 after
4299 return IterableMixinWorkaround.reduce(this, initialValue, combine); 4303 return IterableMixinWorkaround.reduce(this, initialValue, combine);
4300 } 4304 }
4301 4305
4302 bool contains(Number element) => IterableMixinWorkaround.contains(this, elemen t); 4306 bool contains(Number element) => IterableMixinWorkaround.contains(this, elemen t);
4303 4307
4304 void forEach(void f(Number element)) => IterableMixinWorkaround.forEach(this, f); 4308 void forEach(void f(Number element)) => IterableMixinWorkaround.forEach(this, f);
4305 4309
4306 String join([String separator]) => 4310 String join([String separator]) =>
4307 IterableMixinWorkaround.joinList(this, separator); 4311 IterableMixinWorkaround.joinList(this, separator);
4308 4312
4309 List mappedBy(f(Number element)) => IterableMixinWorkaround.mappedByList(this, f); 4313 Iterable map(f(Number element)) =>
4314 IterableMixinWorkaround.map(this, f);
4315
4316 List mappedBy(f(Number element)) =>
4317 IterableMixinWorkaround.mappedByList(this, f);
4310 4318
4311 Iterable<Number> where(bool f(Number element)) => 4319 Iterable<Number> where(bool f(Number element)) =>
4312 IterableMixinWorkaround.where(this, f); 4320 IterableMixinWorkaround.where(this, f);
4313 4321
4314 bool every(bool f(Number element)) => IterableMixinWorkaround.every(this, f); 4322 bool every(bool f(Number element)) => IterableMixinWorkaround.every(this, f);
4315 4323
4316 bool any(bool f(Number element)) => IterableMixinWorkaround.any(this, f); 4324 bool any(bool f(Number element)) => IterableMixinWorkaround.any(this, f);
4317 4325
4318 List<Number> toList() => new List<Number>.from(this); 4326 List<Number> toList() => new List<Number>.from(this);
4319 Set<Number> toSet() => new Set<Number>.from(this); 4327 Set<Number> toSet() => new Set<Number>.from(this);
4320 4328
4321 bool get isEmpty => this.length == 0; 4329 bool get isEmpty => this.length == 0;
4322 4330
4323 List<Number> take(int n) => IterableMixinWorkaround.takeList(this, n); 4331 Iterable<Number> take(int n) => IterableMixinWorkaround.takeList(this, n);
4324 4332
4325 Iterable<Number> takeWhile(bool test(Number value)) { 4333 Iterable<Number> takeWhile(bool test(Number value)) {
4326 return IterableMixinWorkaround.takeWhile(this, test); 4334 return IterableMixinWorkaround.takeWhile(this, test);
4327 } 4335 }
4328 4336
4329 List<Number> skip(int n) => IterableMixinWorkaround.skipList(this, n); 4337 Iterable<Number> skip(int n) => IterableMixinWorkaround.skipList(this, n);
4330 4338
4331 Iterable<Number> skipWhile(bool test(Number value)) { 4339 Iterable<Number> skipWhile(bool test(Number value)) {
4332 return IterableMixinWorkaround.skipWhile(this, test); 4340 return IterableMixinWorkaround.skipWhile(this, test);
4333 } 4341 }
4334 4342
4335 Number firstMatching(bool test(Number value), { Number orElse() }) { 4343 Number firstMatching(bool test(Number value), { Number orElse() }) {
4336 return IterableMixinWorkaround.firstMatching(this, test, orElse); 4344 return IterableMixinWorkaround.firstMatching(this, test, orElse);
4337 } 4345 }
4338 4346
4339 Number lastMatching(bool test(Number value), {Number orElse()}) { 4347 Number lastMatching(bool test(Number value), {Number orElse()}) {
(...skipping 866 matching lines...) Expand 10 before | Expand all | Expand 10 after
5206 return IterableMixinWorkaround.reduce(this, initialValue, combine); 5214 return IterableMixinWorkaround.reduce(this, initialValue, combine);
5207 } 5215 }
5208 5216
5209 bool contains(PathSeg element) => IterableMixinWorkaround.contains(this, eleme nt); 5217 bool contains(PathSeg element) => IterableMixinWorkaround.contains(this, eleme nt);
5210 5218
5211 void forEach(void f(PathSeg element)) => IterableMixinWorkaround.forEach(this, f); 5219 void forEach(void f(PathSeg element)) => IterableMixinWorkaround.forEach(this, f);
5212 5220
5213 String join([String separator]) => 5221 String join([String separator]) =>
5214 IterableMixinWorkaround.joinList(this, separator); 5222 IterableMixinWorkaround.joinList(this, separator);
5215 5223
5216 List mappedBy(f(PathSeg element)) => IterableMixinWorkaround.mappedByList(this , f); 5224 Iterable map(f(PathSeg element)) =>
5225 IterableMixinWorkaround.map(this, f);
5226
5227 List mappedBy(f(PathSeg element)) =>
5228 IterableMixinWorkaround.mappedByList(this, f);
5217 5229
5218 Iterable<PathSeg> where(bool f(PathSeg element)) => 5230 Iterable<PathSeg> where(bool f(PathSeg element)) =>
5219 IterableMixinWorkaround.where(this, f); 5231 IterableMixinWorkaround.where(this, f);
5220 5232
5221 bool every(bool f(PathSeg element)) => IterableMixinWorkaround.every(this, f); 5233 bool every(bool f(PathSeg element)) => IterableMixinWorkaround.every(this, f);
5222 5234
5223 bool any(bool f(PathSeg element)) => IterableMixinWorkaround.any(this, f); 5235 bool any(bool f(PathSeg element)) => IterableMixinWorkaround.any(this, f);
5224 5236
5225 List<PathSeg> toList() => new List<PathSeg>.from(this); 5237 List<PathSeg> toList() => new List<PathSeg>.from(this);
5226 Set<PathSeg> toSet() => new Set<PathSeg>.from(this); 5238 Set<PathSeg> toSet() => new Set<PathSeg>.from(this);
5227 5239
5228 bool get isEmpty => this.length == 0; 5240 bool get isEmpty => this.length == 0;
5229 5241
5230 List<PathSeg> take(int n) => IterableMixinWorkaround.takeList(this, n); 5242 Iterable<PathSeg> take(int n) => IterableMixinWorkaround.takeList(this, n);
5231 5243
5232 Iterable<PathSeg> takeWhile(bool test(PathSeg value)) { 5244 Iterable<PathSeg> takeWhile(bool test(PathSeg value)) {
5233 return IterableMixinWorkaround.takeWhile(this, test); 5245 return IterableMixinWorkaround.takeWhile(this, test);
5234 } 5246 }
5235 5247
5236 List<PathSeg> skip(int n) => IterableMixinWorkaround.skipList(this, n); 5248 Iterable<PathSeg> skip(int n) => IterableMixinWorkaround.skipList(this, n);
5237 5249
5238 Iterable<PathSeg> skipWhile(bool test(PathSeg value)) { 5250 Iterable<PathSeg> skipWhile(bool test(PathSeg value)) {
5239 return IterableMixinWorkaround.skipWhile(this, test); 5251 return IterableMixinWorkaround.skipWhile(this, test);
5240 } 5252 }
5241 5253
5242 PathSeg firstMatching(bool test(PathSeg value), { PathSeg orElse() }) { 5254 PathSeg firstMatching(bool test(PathSeg value), { PathSeg orElse() }) {
5243 return IterableMixinWorkaround.firstMatching(this, test, orElse); 5255 return IterableMixinWorkaround.firstMatching(this, test, orElse);
5244 } 5256 }
5245 5257
5246 PathSeg lastMatching(bool test(PathSeg value), {PathSeg orElse()}) { 5258 PathSeg lastMatching(bool test(PathSeg value), {PathSeg orElse()}) {
(...skipping 885 matching lines...) Expand 10 before | Expand all | Expand 10 after
6132 return IterableMixinWorkaround.reduce(this, initialValue, combine); 6144 return IterableMixinWorkaround.reduce(this, initialValue, combine);
6133 } 6145 }
6134 6146
6135 bool contains(String element) => IterableMixinWorkaround.contains(this, elemen t); 6147 bool contains(String element) => IterableMixinWorkaround.contains(this, elemen t);
6136 6148
6137 void forEach(void f(String element)) => IterableMixinWorkaround.forEach(this, f); 6149 void forEach(void f(String element)) => IterableMixinWorkaround.forEach(this, f);
6138 6150
6139 String join([String separator]) => 6151 String join([String separator]) =>
6140 IterableMixinWorkaround.joinList(this, separator); 6152 IterableMixinWorkaround.joinList(this, separator);
6141 6153
6142 List mappedBy(f(String element)) => IterableMixinWorkaround.mappedByList(this, f); 6154 Iterable map(f(String element)) =>
6155 IterableMixinWorkaround.map(this, f);
6156
6157 List mappedBy(f(String element)) =>
6158 IterableMixinWorkaround.mappedByList(this, f);
6143 6159
6144 Iterable<String> where(bool f(String element)) => 6160 Iterable<String> where(bool f(String element)) =>
6145 IterableMixinWorkaround.where(this, f); 6161 IterableMixinWorkaround.where(this, f);
6146 6162
6147 bool every(bool f(String element)) => IterableMixinWorkaround.every(this, f); 6163 bool every(bool f(String element)) => IterableMixinWorkaround.every(this, f);
6148 6164
6149 bool any(bool f(String element)) => IterableMixinWorkaround.any(this, f); 6165 bool any(bool f(String element)) => IterableMixinWorkaround.any(this, f);
6150 6166
6151 List<String> toList() => new List<String>.from(this); 6167 List<String> toList() => new List<String>.from(this);
6152 Set<String> toSet() => new Set<String>.from(this); 6168 Set<String> toSet() => new Set<String>.from(this);
6153 6169
6154 bool get isEmpty => this.length == 0; 6170 bool get isEmpty => this.length == 0;
6155 6171
6156 List<String> take(int n) => IterableMixinWorkaround.takeList(this, n); 6172 Iterable<String> take(int n) => IterableMixinWorkaround.takeList(this, n);
6157 6173
6158 Iterable<String> takeWhile(bool test(String value)) { 6174 Iterable<String> takeWhile(bool test(String value)) {
6159 return IterableMixinWorkaround.takeWhile(this, test); 6175 return IterableMixinWorkaround.takeWhile(this, test);
6160 } 6176 }
6161 6177
6162 List<String> skip(int n) => IterableMixinWorkaround.skipList(this, n); 6178 Iterable<String> skip(int n) => IterableMixinWorkaround.skipList(this, n);
6163 6179
6164 Iterable<String> skipWhile(bool test(String value)) { 6180 Iterable<String> skipWhile(bool test(String value)) {
6165 return IterableMixinWorkaround.skipWhile(this, test); 6181 return IterableMixinWorkaround.skipWhile(this, test);
6166 } 6182 }
6167 6183
6168 String firstMatching(bool test(String value), { String orElse() }) { 6184 String firstMatching(bool test(String value), { String orElse() }) {
6169 return IterableMixinWorkaround.firstMatching(this, test, orElse); 6185 return IterableMixinWorkaround.firstMatching(this, test, orElse);
6170 } 6186 }
6171 6187
6172 String lastMatching(bool test(String value), {String orElse()}) { 6188 String lastMatching(bool test(String value), {String orElse()}) {
(...skipping 1180 matching lines...) Expand 10 before | Expand all | Expand 10 after
7353 return IterableMixinWorkaround.reduce(this, initialValue, combine); 7369 return IterableMixinWorkaround.reduce(this, initialValue, combine);
7354 } 7370 }
7355 7371
7356 bool contains(Transform element) => IterableMixinWorkaround.contains(this, ele ment); 7372 bool contains(Transform element) => IterableMixinWorkaround.contains(this, ele ment);
7357 7373
7358 void forEach(void f(Transform element)) => IterableMixinWorkaround.forEach(thi s, f); 7374 void forEach(void f(Transform element)) => IterableMixinWorkaround.forEach(thi s, f);
7359 7375
7360 String join([String separator]) => 7376 String join([String separator]) =>
7361 IterableMixinWorkaround.joinList(this, separator); 7377 IterableMixinWorkaround.joinList(this, separator);
7362 7378
7363 List mappedBy(f(Transform element)) => IterableMixinWorkaround.mappedByList(th is, f); 7379 Iterable map(f(Transform element)) =>
7380 IterableMixinWorkaround.map(this, f);
7381
7382 List mappedBy(f(Transform element)) =>
7383 IterableMixinWorkaround.mappedByList(this, f);
7364 7384
7365 Iterable<Transform> where(bool f(Transform element)) => 7385 Iterable<Transform> where(bool f(Transform element)) =>
7366 IterableMixinWorkaround.where(this, f); 7386 IterableMixinWorkaround.where(this, f);
7367 7387
7368 bool every(bool f(Transform element)) => IterableMixinWorkaround.every(this, f ); 7388 bool every(bool f(Transform element)) => IterableMixinWorkaround.every(this, f );
7369 7389
7370 bool any(bool f(Transform element)) => IterableMixinWorkaround.any(this, f); 7390 bool any(bool f(Transform element)) => IterableMixinWorkaround.any(this, f);
7371 7391
7372 List<Transform> toList() => new List<Transform>.from(this); 7392 List<Transform> toList() => new List<Transform>.from(this);
7373 Set<Transform> toSet() => new Set<Transform>.from(this); 7393 Set<Transform> toSet() => new Set<Transform>.from(this);
7374 7394
7375 bool get isEmpty => this.length == 0; 7395 bool get isEmpty => this.length == 0;
7376 7396
7377 List<Transform> take(int n) => IterableMixinWorkaround.takeList(this, n); 7397 Iterable<Transform> take(int n) => IterableMixinWorkaround.takeList(this, n);
7378 7398
7379 Iterable<Transform> takeWhile(bool test(Transform value)) { 7399 Iterable<Transform> takeWhile(bool test(Transform value)) {
7380 return IterableMixinWorkaround.takeWhile(this, test); 7400 return IterableMixinWorkaround.takeWhile(this, test);
7381 } 7401 }
7382 7402
7383 List<Transform> skip(int n) => IterableMixinWorkaround.skipList(this, n); 7403 Iterable<Transform> skip(int n) => IterableMixinWorkaround.skipList(this, n);
7384 7404
7385 Iterable<Transform> skipWhile(bool test(Transform value)) { 7405 Iterable<Transform> skipWhile(bool test(Transform value)) {
7386 return IterableMixinWorkaround.skipWhile(this, test); 7406 return IterableMixinWorkaround.skipWhile(this, test);
7387 } 7407 }
7388 7408
7389 Transform firstMatching(bool test(Transform value), { Transform orElse() }) { 7409 Transform firstMatching(bool test(Transform value), { Transform orElse() }) {
7390 return IterableMixinWorkaround.firstMatching(this, test, orElse); 7410 return IterableMixinWorkaround.firstMatching(this, test, orElse);
7391 } 7411 }
7392 7412
7393 Transform lastMatching(bool test(Transform value), {Transform orElse()}) { 7413 Transform lastMatching(bool test(Transform value), {Transform orElse()}) {
(...skipping 494 matching lines...) Expand 10 before | Expand all | Expand 10 after
7888 return IterableMixinWorkaround.reduce(this, initialValue, combine); 7908 return IterableMixinWorkaround.reduce(this, initialValue, combine);
7889 } 7909 }
7890 7910
7891 bool contains(ElementInstance element) => IterableMixinWorkaround.contains(thi s, element); 7911 bool contains(ElementInstance element) => IterableMixinWorkaround.contains(thi s, element);
7892 7912
7893 void forEach(void f(ElementInstance element)) => IterableMixinWorkaround.forEa ch(this, f); 7913 void forEach(void f(ElementInstance element)) => IterableMixinWorkaround.forEa ch(this, f);
7894 7914
7895 String join([String separator]) => 7915 String join([String separator]) =>
7896 IterableMixinWorkaround.joinList(this, separator); 7916 IterableMixinWorkaround.joinList(this, separator);
7897 7917
7898 List mappedBy(f(ElementInstance element)) => IterableMixinWorkaround.mappedByL ist(this, f); 7918 Iterable map(f(ElementInstance element)) =>
7919 IterableMixinWorkaround.map(this, f);
7920
7921 List mappedBy(f(ElementInstance element)) =>
7922 IterableMixinWorkaround.mappedByList(this, f);
7899 7923
7900 Iterable<ElementInstance> where(bool f(ElementInstance element)) => 7924 Iterable<ElementInstance> where(bool f(ElementInstance element)) =>
7901 IterableMixinWorkaround.where(this, f); 7925 IterableMixinWorkaround.where(this, f);
7902 7926
7903 bool every(bool f(ElementInstance element)) => IterableMixinWorkaround.every(t his, f); 7927 bool every(bool f(ElementInstance element)) => IterableMixinWorkaround.every(t his, f);
7904 7928
7905 bool any(bool f(ElementInstance element)) => IterableMixinWorkaround.any(this, f); 7929 bool any(bool f(ElementInstance element)) => IterableMixinWorkaround.any(this, f);
7906 7930
7907 List<ElementInstance> toList() => new List<ElementInstance>.from(this); 7931 List<ElementInstance> toList() => new List<ElementInstance>.from(this);
7908 Set<ElementInstance> toSet() => new Set<ElementInstance>.from(this); 7932 Set<ElementInstance> toSet() => new Set<ElementInstance>.from(this);
7909 7933
7910 bool get isEmpty => this.length == 0; 7934 bool get isEmpty => this.length == 0;
7911 7935
7912 List<ElementInstance> take(int n) => IterableMixinWorkaround.takeList(this, n) ; 7936 Iterable<ElementInstance> take(int n) => IterableMixinWorkaround.takeList(this , n);
7913 7937
7914 Iterable<ElementInstance> takeWhile(bool test(ElementInstance value)) { 7938 Iterable<ElementInstance> takeWhile(bool test(ElementInstance value)) {
7915 return IterableMixinWorkaround.takeWhile(this, test); 7939 return IterableMixinWorkaround.takeWhile(this, test);
7916 } 7940 }
7917 7941
7918 List<ElementInstance> skip(int n) => IterableMixinWorkaround.skipList(this, n) ; 7942 Iterable<ElementInstance> skip(int n) => IterableMixinWorkaround.skipList(this , n);
7919 7943
7920 Iterable<ElementInstance> skipWhile(bool test(ElementInstance value)) { 7944 Iterable<ElementInstance> skipWhile(bool test(ElementInstance value)) {
7921 return IterableMixinWorkaround.skipWhile(this, test); 7945 return IterableMixinWorkaround.skipWhile(this, test);
7922 } 7946 }
7923 7947
7924 ElementInstance firstMatching(bool test(ElementInstance value), { ElementInsta nce orElse() }) { 7948 ElementInstance firstMatching(bool test(ElementInstance value), { ElementInsta nce orElse() }) {
7925 return IterableMixinWorkaround.firstMatching(this, test, orElse); 7949 return IterableMixinWorkaround.firstMatching(this, test, orElse);
7926 } 7950 }
7927 7951
7928 ElementInstance lastMatching(bool test(ElementInstance value), {ElementInstanc e orElse()}) { 7952 ElementInstance lastMatching(bool test(ElementInstance value), {ElementInstanc e orElse()}) {
(...skipping 111 matching lines...) Expand 10 before | Expand all | Expand 10 after
8040 8064
8041 List<ElementInstance> getRange(int start, int rangeLength) => 8065 List<ElementInstance> getRange(int start, int rangeLength) =>
8042 Lists.getRange(this, start, rangeLength, <ElementInstance>[]); 8066 Lists.getRange(this, start, rangeLength, <ElementInstance>[]);
8043 8067
8044 // -- end List<ElementInstance> mixins. 8068 // -- end List<ElementInstance> mixins.
8045 8069
8046 @DomName('SVGElementInstanceList.item') 8070 @DomName('SVGElementInstanceList.item')
8047 @DocsEditable 8071 @DocsEditable
8048 ElementInstance item(int index) native; 8072 ElementInstance item(int index) native;
8049 } 8073 }
OLDNEW
« no previous file with comments | « sdk/lib/html/html_common/filtered_element_list.dart ('k') | sdk/lib/svg/dartium/svg_dartium.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698