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

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

Issue 14071002: Added new version of reduce. (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart
Patch Set: Removed more uses of max, and a few bugs. Created 7 years, 8 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 dart.dom.svg; 1 library dart.dom.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 - unless you are editing documentation as per: 9 // DO NOT EDIT - unless you are editing documentation as per:
10 // https://code.google.com/p/dart/wiki/ContributingHTMLDocumentation 10 // https://code.google.com/p/dart/wiki/ContributingHTMLDocumentation
(...skipping 3012 matching lines...) Expand 10 before | Expand all | Expand 10 after
3023 3023
3024 Iterator<Length> get iterator { 3024 Iterator<Length> get iterator {
3025 // Note: NodeLists are not fixed size. And most probably length shouldn't 3025 // Note: NodeLists are not fixed size. And most probably length shouldn't
3026 // be cached in both iterator _and_ forEach method. For now caching it 3026 // be cached in both iterator _and_ forEach method. For now caching it
3027 // for consistency. 3027 // for consistency.
3028 return new FixedSizeListIterator<Length>(this); 3028 return new FixedSizeListIterator<Length>(this);
3029 } 3029 }
3030 3030
3031 // SVG Collections expose numberOfItems rather than length. 3031 // SVG Collections expose numberOfItems rather than length.
3032 int get length => numberOfItems; 3032 int get length => numberOfItems;
3033 dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Length)) { 3033 Length reduce(Length combine(Length value, Length element)) {
3034 return IterableMixinWorkaround.reduce(this, initialValue, combine); 3034 return IterableMixinWorkaround.reduce(this, combine);
3035 } 3035 }
3036 3036
3037 dynamic fold(dynamic initialValue, dynamic combine(dynamic, Length)) { 3037 dynamic fold(dynamic initialValue,
3038 dynamic combine(dynamic previousValue, Length element)) {
3038 return IterableMixinWorkaround.fold(this, initialValue, combine); 3039 return IterableMixinWorkaround.fold(this, initialValue, combine);
3039 } 3040 }
3040 3041
3041 bool contains(Length element) => IterableMixinWorkaround.contains(this, elemen t); 3042 bool contains(Length element) => IterableMixinWorkaround.contains(this, elemen t);
3042 3043
3043 void forEach(void f(Length element)) => IterableMixinWorkaround.forEach(this, f); 3044 void forEach(void f(Length element)) => IterableMixinWorkaround.forEach(this, f);
3044 3045
3045 String join([String separator = ""]) => 3046 String join([String separator = ""]) =>
3046 IterableMixinWorkaround.joinList(this, separator); 3047 IterableMixinWorkaround.joinList(this, separator);
3047 3048
(...skipping 87 matching lines...) Expand 10 before | Expand all | Expand 10 after
3135 if (this.length > 0) return this[this.length - 1]; 3136 if (this.length > 0) return this[this.length - 1];
3136 throw new StateError("No elements"); 3137 throw new StateError("No elements");
3137 } 3138 }
3138 3139
3139 Length get single { 3140 Length get single {
3140 if (length == 1) return this[0]; 3141 if (length == 1) return this[0];
3141 if (length == 0) throw new StateError("No elements"); 3142 if (length == 0) throw new StateError("No elements");
3142 throw new StateError("More than one element"); 3143 throw new StateError("More than one element");
3143 } 3144 }
3144 3145
3145 Length min([int compare(Length a, Length b)]) =>
3146 IterableMixinWorkaround.min(this, compare);
3147
3148 Length max([int compare(Length a, Length b)]) =>
3149 IterableMixinWorkaround.max(this, compare);
3150
3151 void insert(int index, Length element) { 3146 void insert(int index, Length element) {
3152 throw new UnsupportedError("Cannot add to immutable List."); 3147 throw new UnsupportedError("Cannot add to immutable List.");
3153 } 3148 }
3154 3149
3155 Length removeAt(int pos) { 3150 Length removeAt(int pos) {
3156 throw new UnsupportedError("Cannot remove from immutable List."); 3151 throw new UnsupportedError("Cannot remove from immutable List.");
3157 } 3152 }
3158 3153
3159 Length removeLast() { 3154 Length removeLast() {
3160 throw new UnsupportedError("Cannot remove from immutable List."); 3155 throw new UnsupportedError("Cannot remove from immutable List.");
(...skipping 507 matching lines...) Expand 10 before | Expand all | Expand 10 after
3668 3663
3669 Iterator<Number> get iterator { 3664 Iterator<Number> get iterator {
3670 // Note: NodeLists are not fixed size. And most probably length shouldn't 3665 // Note: NodeLists are not fixed size. And most probably length shouldn't
3671 // be cached in both iterator _and_ forEach method. For now caching it 3666 // be cached in both iterator _and_ forEach method. For now caching it
3672 // for consistency. 3667 // for consistency.
3673 return new FixedSizeListIterator<Number>(this); 3668 return new FixedSizeListIterator<Number>(this);
3674 } 3669 }
3675 3670
3676 // SVG Collections expose numberOfItems rather than length. 3671 // SVG Collections expose numberOfItems rather than length.
3677 int get length => numberOfItems; 3672 int get length => numberOfItems;
3678 dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Number)) { 3673 Number reduce(Number combine(Number value, Number element)) {
3679 return IterableMixinWorkaround.reduce(this, initialValue, combine); 3674 return IterableMixinWorkaround.reduce(this, combine);
3680 } 3675 }
3681 3676
3682 dynamic fold(dynamic initialValue, dynamic combine(dynamic, Number)) { 3677 dynamic fold(dynamic initialValue,
3678 dynamic combine(dynamic previousValue, Number element)) {
3683 return IterableMixinWorkaround.fold(this, initialValue, combine); 3679 return IterableMixinWorkaround.fold(this, initialValue, combine);
3684 } 3680 }
3685 3681
3686 bool contains(Number element) => IterableMixinWorkaround.contains(this, elemen t); 3682 bool contains(Number element) => IterableMixinWorkaround.contains(this, elemen t);
3687 3683
3688 void forEach(void f(Number element)) => IterableMixinWorkaround.forEach(this, f); 3684 void forEach(void f(Number element)) => IterableMixinWorkaround.forEach(this, f);
3689 3685
3690 String join([String separator = ""]) => 3686 String join([String separator = ""]) =>
3691 IterableMixinWorkaround.joinList(this, separator); 3687 IterableMixinWorkaround.joinList(this, separator);
3692 3688
(...skipping 87 matching lines...) Expand 10 before | Expand all | Expand 10 after
3780 if (this.length > 0) return this[this.length - 1]; 3776 if (this.length > 0) return this[this.length - 1];
3781 throw new StateError("No elements"); 3777 throw new StateError("No elements");
3782 } 3778 }
3783 3779
3784 Number get single { 3780 Number get single {
3785 if (length == 1) return this[0]; 3781 if (length == 1) return this[0];
3786 if (length == 0) throw new StateError("No elements"); 3782 if (length == 0) throw new StateError("No elements");
3787 throw new StateError("More than one element"); 3783 throw new StateError("More than one element");
3788 } 3784 }
3789 3785
3790 Number min([int compare(Number a, Number b)]) =>
3791 IterableMixinWorkaround.min(this, compare);
3792
3793 Number max([int compare(Number a, Number b)]) =>
3794 IterableMixinWorkaround.max(this, compare);
3795
3796 void insert(int index, Number element) { 3786 void insert(int index, Number element) {
3797 throw new UnsupportedError("Cannot add to immutable List."); 3787 throw new UnsupportedError("Cannot add to immutable List.");
3798 } 3788 }
3799 3789
3800 Number removeAt(int pos) { 3790 Number removeAt(int pos) {
3801 throw new UnsupportedError("Cannot remove from immutable List."); 3791 throw new UnsupportedError("Cannot remove from immutable List.");
3802 } 3792 }
3803 3793
3804 Number removeLast() { 3794 Number removeLast() {
3805 throw new UnsupportedError("Cannot remove from immutable List."); 3795 throw new UnsupportedError("Cannot remove from immutable List.");
(...skipping 738 matching lines...) Expand 10 before | Expand all | Expand 10 after
4544 4534
4545 Iterator<PathSeg> get iterator { 4535 Iterator<PathSeg> get iterator {
4546 // Note: NodeLists are not fixed size. And most probably length shouldn't 4536 // Note: NodeLists are not fixed size. And most probably length shouldn't
4547 // be cached in both iterator _and_ forEach method. For now caching it 4537 // be cached in both iterator _and_ forEach method. For now caching it
4548 // for consistency. 4538 // for consistency.
4549 return new FixedSizeListIterator<PathSeg>(this); 4539 return new FixedSizeListIterator<PathSeg>(this);
4550 } 4540 }
4551 4541
4552 // SVG Collections expose numberOfItems rather than length. 4542 // SVG Collections expose numberOfItems rather than length.
4553 int get length => numberOfItems; 4543 int get length => numberOfItems;
4554 dynamic reduce(dynamic initialValue, dynamic combine(dynamic, PathSeg)) { 4544 PathSeg reduce(PathSeg combine(PathSeg value, PathSeg element)) {
4555 return IterableMixinWorkaround.reduce(this, initialValue, combine); 4545 return IterableMixinWorkaround.reduce(this, combine);
4556 } 4546 }
4557 4547
4558 dynamic fold(dynamic initialValue, dynamic combine(dynamic, PathSeg)) { 4548 dynamic fold(dynamic initialValue,
4549 dynamic combine(dynamic previousValue, PathSeg element)) {
4559 return IterableMixinWorkaround.fold(this, initialValue, combine); 4550 return IterableMixinWorkaround.fold(this, initialValue, combine);
4560 } 4551 }
4561 4552
4562 bool contains(PathSeg element) => IterableMixinWorkaround.contains(this, eleme nt); 4553 bool contains(PathSeg element) => IterableMixinWorkaround.contains(this, eleme nt);
4563 4554
4564 void forEach(void f(PathSeg element)) => IterableMixinWorkaround.forEach(this, f); 4555 void forEach(void f(PathSeg element)) => IterableMixinWorkaround.forEach(this, f);
4565 4556
4566 String join([String separator = ""]) => 4557 String join([String separator = ""]) =>
4567 IterableMixinWorkaround.joinList(this, separator); 4558 IterableMixinWorkaround.joinList(this, separator);
4568 4559
(...skipping 87 matching lines...) Expand 10 before | Expand all | Expand 10 after
4656 if (this.length > 0) return this[this.length - 1]; 4647 if (this.length > 0) return this[this.length - 1];
4657 throw new StateError("No elements"); 4648 throw new StateError("No elements");
4658 } 4649 }
4659 4650
4660 PathSeg get single { 4651 PathSeg get single {
4661 if (length == 1) return this[0]; 4652 if (length == 1) return this[0];
4662 if (length == 0) throw new StateError("No elements"); 4653 if (length == 0) throw new StateError("No elements");
4663 throw new StateError("More than one element"); 4654 throw new StateError("More than one element");
4664 } 4655 }
4665 4656
4666 PathSeg min([int compare(PathSeg a, PathSeg b)]) =>
4667 IterableMixinWorkaround.min(this, compare);
4668
4669 PathSeg max([int compare(PathSeg a, PathSeg b)]) =>
4670 IterableMixinWorkaround.max(this, compare);
4671
4672 void insert(int index, PathSeg element) { 4657 void insert(int index, PathSeg element) {
4673 throw new UnsupportedError("Cannot add to immutable List."); 4658 throw new UnsupportedError("Cannot add to immutable List.");
4674 } 4659 }
4675 4660
4676 PathSeg removeAt(int pos) { 4661 PathSeg removeAt(int pos) {
4677 throw new UnsupportedError("Cannot remove from immutable List."); 4662 throw new UnsupportedError("Cannot remove from immutable List.");
4678 } 4663 }
4679 4664
4680 PathSeg removeLast() { 4665 PathSeg removeLast() {
4681 throw new UnsupportedError("Cannot remove from immutable List."); 4666 throw new UnsupportedError("Cannot remove from immutable List.");
(...skipping 768 matching lines...) Expand 10 before | Expand all | Expand 10 after
5450 5435
5451 Iterator<String> get iterator { 5436 Iterator<String> get iterator {
5452 // Note: NodeLists are not fixed size. And most probably length shouldn't 5437 // Note: NodeLists are not fixed size. And most probably length shouldn't
5453 // be cached in both iterator _and_ forEach method. For now caching it 5438 // be cached in both iterator _and_ forEach method. For now caching it
5454 // for consistency. 5439 // for consistency.
5455 return new FixedSizeListIterator<String>(this); 5440 return new FixedSizeListIterator<String>(this);
5456 } 5441 }
5457 5442
5458 // SVG Collections expose numberOfItems rather than length. 5443 // SVG Collections expose numberOfItems rather than length.
5459 int get length => numberOfItems; 5444 int get length => numberOfItems;
5460 dynamic reduce(dynamic initialValue, dynamic combine(dynamic, String)) { 5445 String reduce(String combine(String value, String element)) {
5461 return IterableMixinWorkaround.reduce(this, initialValue, combine); 5446 return IterableMixinWorkaround.reduce(this, combine);
5462 } 5447 }
5463 5448
5464 dynamic fold(dynamic initialValue, dynamic combine(dynamic, String)) { 5449 dynamic fold(dynamic initialValue,
5450 dynamic combine(dynamic previousValue, String element)) {
5465 return IterableMixinWorkaround.fold(this, initialValue, combine); 5451 return IterableMixinWorkaround.fold(this, initialValue, combine);
5466 } 5452 }
5467 5453
5468 bool contains(String element) => IterableMixinWorkaround.contains(this, elemen t); 5454 bool contains(String element) => IterableMixinWorkaround.contains(this, elemen t);
5469 5455
5470 void forEach(void f(String element)) => IterableMixinWorkaround.forEach(this, f); 5456 void forEach(void f(String element)) => IterableMixinWorkaround.forEach(this, f);
5471 5457
5472 String join([String separator = ""]) => 5458 String join([String separator = ""]) =>
5473 IterableMixinWorkaround.joinList(this, separator); 5459 IterableMixinWorkaround.joinList(this, separator);
5474 5460
(...skipping 87 matching lines...) Expand 10 before | Expand all | Expand 10 after
5562 if (this.length > 0) return this[this.length - 1]; 5548 if (this.length > 0) return this[this.length - 1];
5563 throw new StateError("No elements"); 5549 throw new StateError("No elements");
5564 } 5550 }
5565 5551
5566 String get single { 5552 String get single {
5567 if (length == 1) return this[0]; 5553 if (length == 1) return this[0];
5568 if (length == 0) throw new StateError("No elements"); 5554 if (length == 0) throw new StateError("No elements");
5569 throw new StateError("More than one element"); 5555 throw new StateError("More than one element");
5570 } 5556 }
5571 5557
5572 String min([int compare(String a, String b)]) =>
5573 IterableMixinWorkaround.min(this, compare);
5574
5575 String max([int compare(String a, String b)]) =>
5576 IterableMixinWorkaround.max(this, compare);
5577
5578 void insert(int index, String element) { 5558 void insert(int index, String element) {
5579 throw new UnsupportedError("Cannot add to immutable List."); 5559 throw new UnsupportedError("Cannot add to immutable List.");
5580 } 5560 }
5581 5561
5582 String removeAt(int pos) { 5562 String removeAt(int pos) {
5583 throw new UnsupportedError("Cannot remove from immutable List."); 5563 throw new UnsupportedError("Cannot remove from immutable List.");
5584 } 5564 }
5585 5565
5586 String removeLast() { 5566 String removeLast() {
5587 throw new UnsupportedError("Cannot remove from immutable List."); 5567 throw new UnsupportedError("Cannot remove from immutable List.");
(...skipping 1041 matching lines...) Expand 10 before | Expand all | Expand 10 after
6629 6609
6630 Iterator<Transform> get iterator { 6610 Iterator<Transform> get iterator {
6631 // Note: NodeLists are not fixed size. And most probably length shouldn't 6611 // Note: NodeLists are not fixed size. And most probably length shouldn't
6632 // be cached in both iterator _and_ forEach method. For now caching it 6612 // be cached in both iterator _and_ forEach method. For now caching it
6633 // for consistency. 6613 // for consistency.
6634 return new FixedSizeListIterator<Transform>(this); 6614 return new FixedSizeListIterator<Transform>(this);
6635 } 6615 }
6636 6616
6637 // SVG Collections expose numberOfItems rather than length. 6617 // SVG Collections expose numberOfItems rather than length.
6638 int get length => numberOfItems; 6618 int get length => numberOfItems;
6639 dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Transform)) { 6619 Transform reduce(Transform combine(Transform value, Transform element)) {
6640 return IterableMixinWorkaround.reduce(this, initialValue, combine); 6620 return IterableMixinWorkaround.reduce(this, combine);
6641 } 6621 }
6642 6622
6643 dynamic fold(dynamic initialValue, dynamic combine(dynamic, Transform)) { 6623 dynamic fold(dynamic initialValue,
6624 dynamic combine(dynamic previousValue, Transform element)) {
6644 return IterableMixinWorkaround.fold(this, initialValue, combine); 6625 return IterableMixinWorkaround.fold(this, initialValue, combine);
6645 } 6626 }
6646 6627
6647 bool contains(Transform element) => IterableMixinWorkaround.contains(this, ele ment); 6628 bool contains(Transform element) => IterableMixinWorkaround.contains(this, ele ment);
6648 6629
6649 void forEach(void f(Transform element)) => IterableMixinWorkaround.forEach(thi s, f); 6630 void forEach(void f(Transform element)) => IterableMixinWorkaround.forEach(thi s, f);
6650 6631
6651 String join([String separator = ""]) => 6632 String join([String separator = ""]) =>
6652 IterableMixinWorkaround.joinList(this, separator); 6633 IterableMixinWorkaround.joinList(this, separator);
6653 6634
(...skipping 87 matching lines...) Expand 10 before | Expand all | Expand 10 after
6741 if (this.length > 0) return this[this.length - 1]; 6722 if (this.length > 0) return this[this.length - 1];
6742 throw new StateError("No elements"); 6723 throw new StateError("No elements");
6743 } 6724 }
6744 6725
6745 Transform get single { 6726 Transform get single {
6746 if (length == 1) return this[0]; 6727 if (length == 1) return this[0];
6747 if (length == 0) throw new StateError("No elements"); 6728 if (length == 0) throw new StateError("No elements");
6748 throw new StateError("More than one element"); 6729 throw new StateError("More than one element");
6749 } 6730 }
6750 6731
6751 Transform min([int compare(Transform a, Transform b)]) =>
6752 IterableMixinWorkaround.min(this, compare);
6753
6754 Transform max([int compare(Transform a, Transform b)]) =>
6755 IterableMixinWorkaround.max(this, compare);
6756
6757 void insert(int index, Transform element) { 6732 void insert(int index, Transform element) {
6758 throw new UnsupportedError("Cannot add to immutable List."); 6733 throw new UnsupportedError("Cannot add to immutable List.");
6759 } 6734 }
6760 6735
6761 Transform removeAt(int pos) { 6736 Transform removeAt(int pos) {
6762 throw new UnsupportedError("Cannot remove from immutable List."); 6737 throw new UnsupportedError("Cannot remove from immutable List.");
6763 } 6738 }
6764 6739
6765 Transform removeLast() { 6740 Transform removeLast() {
6766 throw new UnsupportedError("Cannot remove from immutable List."); 6741 throw new UnsupportedError("Cannot remove from immutable List.");
(...skipping 400 matching lines...) Expand 10 before | Expand all | Expand 10 after
7167 7142
7168 // From Iterable<ElementInstance>: 7143 // From Iterable<ElementInstance>:
7169 7144
7170 Iterator<ElementInstance> get iterator { 7145 Iterator<ElementInstance> get iterator {
7171 // Note: NodeLists are not fixed size. And most probably length shouldn't 7146 // Note: NodeLists are not fixed size. And most probably length shouldn't
7172 // be cached in both iterator _and_ forEach method. For now caching it 7147 // be cached in both iterator _and_ forEach method. For now caching it
7173 // for consistency. 7148 // for consistency.
7174 return new FixedSizeListIterator<ElementInstance>(this); 7149 return new FixedSizeListIterator<ElementInstance>(this);
7175 } 7150 }
7176 7151
7177 dynamic reduce(dynamic initialValue, dynamic combine(dynamic, ElementInstance) ) { 7152 ElementInstance reduce(ElementInstance combine(ElementInstance value, ElementI nstance element)) {
7178 return IterableMixinWorkaround.reduce(this, initialValue, combine); 7153 return IterableMixinWorkaround.reduce(this, combine);
7179 } 7154 }
7180 7155
7181 dynamic fold(dynamic initialValue, dynamic combine(dynamic, ElementInstance)) { 7156 dynamic fold(dynamic initialValue,
7157 dynamic combine(dynamic previousValue, ElementInstance element)) {
7182 return IterableMixinWorkaround.fold(this, initialValue, combine); 7158 return IterableMixinWorkaround.fold(this, initialValue, combine);
7183 } 7159 }
7184 7160
7185 bool contains(ElementInstance element) => IterableMixinWorkaround.contains(thi s, element); 7161 bool contains(ElementInstance element) => IterableMixinWorkaround.contains(thi s, element);
7186 7162
7187 void forEach(void f(ElementInstance element)) => IterableMixinWorkaround.forEa ch(this, f); 7163 void forEach(void f(ElementInstance element)) => IterableMixinWorkaround.forEa ch(this, f);
7188 7164
7189 String join([String separator = ""]) => 7165 String join([String separator = ""]) =>
7190 IterableMixinWorkaround.joinList(this, separator); 7166 IterableMixinWorkaround.joinList(this, separator);
7191 7167
(...skipping 89 matching lines...) Expand 10 before | Expand all | Expand 10 after
7281 if (this.length > 0) return this[this.length - 1]; 7257 if (this.length > 0) return this[this.length - 1];
7282 throw new StateError("No elements"); 7258 throw new StateError("No elements");
7283 } 7259 }
7284 7260
7285 ElementInstance get single { 7261 ElementInstance get single {
7286 if (length == 1) return this[0]; 7262 if (length == 1) return this[0];
7287 if (length == 0) throw new StateError("No elements"); 7263 if (length == 0) throw new StateError("No elements");
7288 throw new StateError("More than one element"); 7264 throw new StateError("More than one element");
7289 } 7265 }
7290 7266
7291 ElementInstance min([int compare(ElementInstance a, ElementInstance b)]) =>
7292 IterableMixinWorkaround.min(this, compare);
7293
7294 ElementInstance max([int compare(ElementInstance a, ElementInstance b)]) =>
7295 IterableMixinWorkaround.max(this, compare);
7296
7297 void insert(int index, ElementInstance element) { 7267 void insert(int index, ElementInstance element) {
7298 throw new UnsupportedError("Cannot add to immutable List."); 7268 throw new UnsupportedError("Cannot add to immutable List.");
7299 } 7269 }
7300 7270
7301 ElementInstance removeAt(int pos) { 7271 ElementInstance removeAt(int pos) {
7302 throw new UnsupportedError("Cannot remove from immutable List."); 7272 throw new UnsupportedError("Cannot remove from immutable List.");
7303 } 7273 }
7304 7274
7305 ElementInstance removeLast() { 7275 ElementInstance removeLast() {
7306 throw new UnsupportedError("Cannot remove from immutable List."); 7276 throw new UnsupportedError("Cannot remove from immutable List.");
(...skipping 324 matching lines...) Expand 10 before | Expand all | Expand 10 after
7631 7601
7632 7602
7633 @DocsEditable 7603 @DocsEditable
7634 @DomName('SVGVKernElement') 7604 @DomName('SVGVKernElement')
7635 abstract class _SVGVKernElement extends SvgElement native "*SVGVKernElement" { 7605 abstract class _SVGVKernElement extends SvgElement native "*SVGVKernElement" {
7636 7606
7637 @DomName('SVGVKernElement.SVGVKernElement') 7607 @DomName('SVGVKernElement.SVGVKernElement')
7638 @DocsEditable 7608 @DocsEditable
7639 factory _SVGVKernElement() => _SvgElementFactoryProvider.createSvgElement_tag( "vkern"); 7609 factory _SVGVKernElement() => _SvgElementFactoryProvider.createSvgElement_tag( "vkern");
7640 } 7610 }
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698