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

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: test/codegen/expect/dart/_internal.js

Issue 1020043002: Replace dart_core.js with actual compiled SDK (Closed) Base URL: git@github.com:dart-lang/dev_compiler.git@master
Patch Set: Created 5 years, 9 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
« lib/src/utils.dart ('K') | « test/codegen/expect/dart/_interceptors.js ('k') | test/codegen/expect/dart/_isolate_helper.js » ('j') | test/generated_sdk/lib/core/function.dart » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 var _internal;
2 (function(exports) {
3 'use strict';
4 class EfficientLength extends core.Object {
5 }
6 let ListIterable$ = dart.generic(function(E) {
7 class ListIterable extends collection.IterableBase$(E) {
8 ListIterable() {
9 super.IterableBase();
10 }
11 get iterator() {
12 return new ListIterator(this);
13 }
14 forEach(action) {
15 let length = this.length;
16 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull (i) + 1) {
17 action(this.elementAt(i));
18 if (length !== this.length) {
19 throw new core.ConcurrentModificationError(this);
20 }
21 }
22 }
23 get isEmpty() {
24 return this.length === 0;
25 }
26 get first() {
27 if (this.length === 0)
28 throw IterableElementError.noElement();
29 return this.elementAt(0);
30 }
31 get last() {
32 if (this.length === 0)
33 throw IterableElementError.noElement();
34 return this.elementAt(dart.notNull(this.length) - 1);
35 }
36 get single() {
37 if (this.length === 0)
38 throw IterableElementError.noElement();
39 if (dart.notNull(this.length) > 1)
40 throw IterableElementError.tooMany();
41 return this.elementAt(0);
42 }
43 contains(element) {
44 let length = this.length;
45 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull (i) + 1) {
46 if (dart.equals(this.elementAt(i), element))
47 return true;
48 if (length !== this.length) {
49 throw new core.ConcurrentModificationError(this);
50 }
51 }
52 return false;
53 }
54 every(test) {
55 let length = this.length;
56 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull (i) + 1) {
57 if (!dart.notNull(test(this.elementAt(i))))
58 return false;
59 if (length !== this.length) {
60 throw new core.ConcurrentModificationError(this);
61 }
62 }
63 return true;
64 }
65 any(test) {
66 let length = this.length;
67 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull (i) + 1) {
68 if (test(this.elementAt(i)))
69 return true;
70 if (length !== this.length) {
71 throw new core.ConcurrentModificationError(this);
72 }
73 }
74 return false;
75 }
76 firstWhere(test, opt$) {
77 let orElse = opt$.orElse === void 0 ? null : opt$.orElse;
78 let length = this.length;
79 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull (i) + 1) {
80 let element = this.elementAt(i);
81 if (test(element))
82 return element;
83 if (length !== this.length) {
84 throw new core.ConcurrentModificationError(this);
85 }
86 }
87 if (orElse !== null)
88 return orElse();
89 throw IterableElementError.noElement();
90 }
91 lastWhere(test, opt$) {
92 let orElse = opt$.orElse === void 0 ? null : opt$.orElse;
93 let length = this.length;
94 for (let i = dart.notNull(length) - 1; dart.notNull(i) >= 0; i = dart.no tNull(i) - 1) {
95 let element = this.elementAt(i);
96 if (test(element))
97 return element;
98 if (length !== this.length) {
99 throw new core.ConcurrentModificationError(this);
100 }
101 }
102 if (orElse !== null)
103 return orElse();
104 throw IterableElementError.noElement();
105 }
106 singleWhere(test) {
107 let length = this.length;
108 let match = null;
109 let matchFound = false;
110 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull (i) + 1) {
111 let element = this.elementAt(i);
112 if (test(element)) {
113 if (matchFound) {
114 throw IterableElementError.tooMany();
115 }
116 matchFound = true;
117 match = element;
118 }
119 if (length !== this.length) {
120 throw new core.ConcurrentModificationError(this);
121 }
122 }
123 if (matchFound)
124 return match;
125 throw IterableElementError.noElement();
126 }
127 join(separator) {
128 if (separator === void 0)
129 separator = "";
130 let length = this.length;
131 if (!dart.notNull(separator.isEmpty)) {
132 if (length === 0)
133 return "";
134 let first = `${this.elementAt(0)}`;
135 if (length !== this.length) {
136 throw new core.ConcurrentModificationError(this);
137 }
138 let buffer = new core.StringBuffer(first);
139 for (let i = 1; dart.notNull(i) < dart.notNull(length); i = dart.notNu ll(i) + 1) {
140 buffer.write(separator);
141 buffer.write(this.elementAt(i));
142 if (length !== this.length) {
143 throw new core.ConcurrentModificationError(this);
144 }
145 }
146 return buffer.toString();
147 } else {
148 let buffer = new core.StringBuffer();
149 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNu ll(i) + 1) {
150 buffer.write(this.elementAt(i));
151 if (length !== this.length) {
152 throw new core.ConcurrentModificationError(this);
153 }
154 }
155 return buffer.toString();
156 }
157 }
158 where(test) {
159 return super.where(test);
160 }
161 map(f) {
162 return new MappedListIterable(this, f);
163 }
164 reduce(combine) {
165 let length = this.length;
166 if (length === 0)
167 throw IterableElementError.noElement();
168 let value = this.elementAt(0);
169 for (let i = 1; dart.notNull(i) < dart.notNull(length); i = dart.notNull (i) + 1) {
170 value = dart.dinvokef(combine, value, this.elementAt(i));
171 if (length !== this.length) {
172 throw new core.ConcurrentModificationError(this);
173 }
174 }
175 return value;
176 }
177 fold(initialValue, combine) {
178 let value = initialValue;
179 let length = this.length;
180 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull (i) + 1) {
181 value = dart.dinvokef(combine, value, this.elementAt(i));
182 if (length !== this.length) {
183 throw new core.ConcurrentModificationError(this);
184 }
185 }
186 return value;
187 }
188 skip(count) {
189 return new SubListIterable(this, count, null);
190 }
191 skipWhile(test) {
192 return super.skipWhile(test);
193 }
194 take(count) {
195 return new SubListIterable(this, 0, count);
196 }
197 takeWhile(test) {
198 return super.takeWhile(test);
199 }
200 toList(opt$) {
201 let growable = opt$.growable === void 0 ? true : opt$.growable;
202 let result = null;
203 if (growable) {
204 result = ((_) => {
205 _.length = this.length;
206 return _;
207 }).bind(this)(new core.List());
208 } else {
209 result = new core.List(this.length);
210 }
211 for (let i = 0; dart.notNull(i) < dart.notNull(this.length); i = dart.no tNull(i) + 1) {
212 result.set(i, this.elementAt(i));
213 }
214 return result;
215 }
216 toSet() {
217 let result = new core.Set();
218 for (let i = 0; dart.notNull(i) < dart.notNull(this.length); i = dart.no tNull(i) + 1) {
219 result.add(this.elementAt(i));
220 }
221 return result;
222 }
223 }
224 return ListIterable;
225 });
226 let ListIterable = ListIterable$(dart.dynamic);
227 let _iterable = Symbol('_iterable');
228 let _start = Symbol('_start');
229 let _endOrLength = Symbol('_endOrLength');
230 let _endIndex = Symbol('_endIndex');
231 let _startIndex = Symbol('_startIndex');
232 let SubListIterable$ = dart.generic(function(E) {
233 class SubListIterable extends ListIterable$(E) {
234 SubListIterable($_iterable, $_start, $_endOrLength) {
235 this[_iterable] = $_iterable;
236 this[_start] = $_start;
237 this[_endOrLength] = $_endOrLength;
238 super.ListIterable();
239 core.RangeError.checkNotNegative(this[_start], "start");
240 if (this[_endOrLength] !== null) {
241 core.RangeError.checkNotNegative(this[_endOrLength], "end");
242 if (dart.notNull(this[_start]) > dart.notNull(this[_endOrLength])) {
243 throw new core.RangeError.range(this[_start], 0, this[_endOrLength], "start");
244 }
245 }
246 }
247 get [_endIndex]() {
248 let length = this[_iterable].length;
249 if (this[_endOrLength] === null || dart.notNull(this[_endOrLength]) > da rt.notNull(length))
250 return length;
251 return this[_endOrLength];
252 }
253 get [_startIndex]() {
254 let length = this[_iterable].length;
255 if (dart.notNull(this[_start]) > dart.notNull(length))
256 return length;
257 return this[_start];
258 }
259 get length() {
260 let length = this[_iterable].length;
261 if (dart.notNull(this[_start]) >= dart.notNull(length))
262 return 0;
263 if (this[_endOrLength] === null || dart.notNull(this[_endOrLength]) >= d art.notNull(length)) {
264 return dart.notNull(length) - dart.notNull(this[_start]);
265 }
266 return dart.notNull(this[_endOrLength]) - dart.notNull(this[_start]);
267 }
268 elementAt(index) {
269 let realIndex = dart.notNull(this[_startIndex]) + dart.notNull(index);
270 if (dart.notNull(index) < 0 || dart.notNull(realIndex) >= dart.notNull(t his[_endIndex])) {
271 throw new core.RangeError.index(index, this, "index");
272 }
273 return this[_iterable].elementAt(realIndex);
274 }
275 skip(count) {
276 core.RangeError.checkNotNegative(count, "count");
277 let newStart = dart.notNull(this[_start]) + dart.notNull(count);
278 if (this[_endOrLength] !== null && dart.notNull(newStart) >= dart.notNul l(this[_endOrLength])) {
279 return new EmptyIterable();
280 }
281 return new SubListIterable(this[_iterable], newStart, this[_endOrLength] );
282 }
283 take(count) {
284 core.RangeError.checkNotNegative(count, "count");
285 if (this[_endOrLength] === null) {
286 return new SubListIterable(this[_iterable], this[_start], dart.notNull (this[_start]) + dart.notNull(count));
287 } else {
288 let newEnd = dart.notNull(this[_start]) + dart.notNull(count);
289 if (dart.notNull(this[_endOrLength]) < dart.notNull(newEnd))
290 return this;
291 return new SubListIterable(this[_iterable], this[_start], newEnd);
292 }
293 }
294 toList(opt$) {
295 let growable = opt$.growable === void 0 ? true : opt$.growable;
296 let start = this[_start];
297 let end = this[_iterable].length;
298 if (this[_endOrLength] !== null && dart.notNull(this[_endOrLength]) < da rt.notNull(end))
299 end = this[_endOrLength];
300 let length = dart.notNull(end) - dart.notNull(start);
301 if (dart.notNull(length) < 0)
302 length = 0;
303 let result = growable ? ((_) => {
304 _.length = length;
305 return _;
306 }).bind(this)(new core.List()) : new core.List(length);
307 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull (i) + 1) {
308 result.set(i, this[_iterable].elementAt(dart.notNull(start) + dart.not Null(i)));
309 if (dart.notNull(this[_iterable].length) < dart.notNull(end))
310 throw new core.ConcurrentModificationError(this);
311 }
312 return dart.as(result, core.List$(E));
313 }
314 }
315 return SubListIterable;
316 });
317 let SubListIterable = SubListIterable$(dart.dynamic);
318 let _length = Symbol('_length');
319 let _index = Symbol('_index');
320 let _current = Symbol('_current');
321 let ListIterator$ = dart.generic(function(E) {
322 class ListIterator extends core.Object {
323 ListIterator(iterable) {
324 this[_iterable] = iterable;
325 this[_length] = iterable.length;
326 this[_index] = 0;
327 this[_current] = null;
328 }
329 get current() {
330 return this[_current];
331 }
332 moveNext() {
333 let length = this[_iterable].length;
334 if (this[_length] !== length) {
335 throw new core.ConcurrentModificationError(this[_iterable]);
336 }
337 if (dart.notNull(this[_index]) >= dart.notNull(length)) {
338 this[_current] = null;
339 return false;
340 }
341 this[_current] = this[_iterable].elementAt(this[_index]);
342 this[_index] = dart.notNull(this[_index]) + 1;
343 return true;
344 }
345 }
346 return ListIterator;
347 });
348 let ListIterator = ListIterator$(dart.dynamic);
349 let _f = Symbol('_f');
350 let MappedIterable$ = dart.generic(function(S, T) {
351 class MappedIterable extends collection.IterableBase$(T) {
352 MappedIterable(iterable, function) {
353 if (dart.is(iterable, EfficientLength)) {
354 return new EfficientLengthMappedIterable(iterable, function);
355 }
356 return new MappedIterable._(dart.as(iterable, core.Iterable$(S)), functi on);
357 }
358 MappedIterable$_($_iterable, $_f) {
359 this[_iterable] = $_iterable;
360 this[_f] = $_f;
361 super.IterableBase();
362 }
363 get iterator() {
364 return new MappedIterator(this[_iterable].iterator, this[_f]);
365 }
366 get length() {
367 return this[_iterable].length;
368 }
369 get isEmpty() {
370 return this[_iterable].isEmpty;
371 }
372 get first() {
373 return this[_f](this[_iterable].first);
374 }
375 get last() {
376 return this[_f](this[_iterable].last);
377 }
378 get single() {
379 return this[_f](this[_iterable].single);
380 }
381 elementAt(index) {
382 return this[_f](this[_iterable].elementAt(index));
383 }
384 }
385 dart.defineNamedConstructor(MappedIterable, '_');
386 return MappedIterable;
387 });
388 let MappedIterable = MappedIterable$(dart.dynamic, dart.dynamic);
389 let EfficientLengthMappedIterable$ = dart.generic(function(S, T) {
390 class EfficientLengthMappedIterable extends MappedIterable$(S, T) {
391 EfficientLengthMappedIterable(iterable, function) {
392 super.MappedIterable$_(dart.as(iterable, core.Iterable$(S)), function);
393 }
394 }
395 return EfficientLengthMappedIterable;
396 });
397 let EfficientLengthMappedIterable = EfficientLengthMappedIterable$(dart.dynami c, dart.dynamic);
398 let _iterator = Symbol('_iterator');
399 let MappedIterator$ = dart.generic(function(S, T) {
400 class MappedIterator extends core.Iterator$(T) {
401 MappedIterator($_iterator, $_f) {
402 this[_iterator] = $_iterator;
403 this[_f] = $_f;
404 this[_current] = null;
405 super.Iterator();
406 }
407 moveNext() {
408 if (this[_iterator].moveNext()) {
409 this[_current] = this[_f](this[_iterator].current);
410 return true;
411 }
412 this[_current] = null;
413 return false;
414 }
415 get current() {
416 return this[_current];
417 }
418 }
419 return MappedIterator;
420 });
421 let MappedIterator = MappedIterator$(dart.dynamic, dart.dynamic);
422 let _source = Symbol('_source');
423 let MappedListIterable$ = dart.generic(function(S, T) {
424 class MappedListIterable extends ListIterable$(T) {
425 MappedListIterable($_source, $_f) {
426 this[_source] = $_source;
427 this[_f] = $_f;
428 super.ListIterable();
429 }
430 get length() {
431 return this[_source].length;
432 }
433 elementAt(index) {
434 return this[_f](this[_source].elementAt(index));
435 }
436 }
437 return MappedListIterable;
438 });
439 let MappedListIterable = MappedListIterable$(dart.dynamic, dart.dynamic);
440 let WhereIterable$ = dart.generic(function(E) {
441 class WhereIterable extends collection.IterableBase$(E) {
442 WhereIterable($_iterable, $_f) {
443 this[_iterable] = $_iterable;
444 this[_f] = $_f;
445 super.IterableBase();
446 }
447 get iterator() {
448 return new WhereIterator(this[_iterable].iterator, this[_f]);
449 }
450 }
451 return WhereIterable;
452 });
453 let WhereIterable = WhereIterable$(dart.dynamic);
454 let WhereIterator$ = dart.generic(function(E) {
455 class WhereIterator extends core.Iterator$(E) {
456 WhereIterator($_iterator, $_f) {
457 this[_iterator] = $_iterator;
458 this[_f] = $_f;
459 super.Iterator();
460 }
461 moveNext() {
462 while (this[_iterator].moveNext()) {
463 if (this[_f](this[_iterator].current)) {
464 return true;
465 }
466 }
467 return false;
468 }
469 get current() {
470 return this[_iterator].current;
471 }
472 }
473 return WhereIterator;
474 });
475 let WhereIterator = WhereIterator$(dart.dynamic);
476 let ExpandIterable$ = dart.generic(function(S, T) {
477 class ExpandIterable extends collection.IterableBase$(T) {
478 ExpandIterable($_iterable, $_f) {
479 this[_iterable] = $_iterable;
480 this[_f] = $_f;
481 super.IterableBase();
482 }
483 get iterator() {
484 return new ExpandIterator(this[_iterable].iterator, dart.closureWrap(thi s[_f], "(S) → Iterable<T>"));
485 }
486 }
487 return ExpandIterable;
488 });
489 let ExpandIterable = ExpandIterable$(dart.dynamic, dart.dynamic);
490 let _currentExpansion = Symbol('_currentExpansion');
491 let _nextExpansion = Symbol('_nextExpansion');
492 let ExpandIterator$ = dart.generic(function(S, T) {
493 class ExpandIterator extends core.Object {
494 ExpandIterator($_iterator, $_f) {
495 this[_iterator] = $_iterator;
496 this[_f] = $_f;
497 this[_currentExpansion] = dart.as(new EmptyIterator(), core.Iterator$(T) );
498 this[_current] = null;
499 }
500 [_nextExpansion]() {}
501 get current() {
502 return this[_current];
503 }
504 moveNext() {
505 if (this[_currentExpansion] === null)
506 return false;
507 while (!dart.notNull(this[_currentExpansion].moveNext())) {
508 this[_current] = null;
509 if (this[_iterator].moveNext()) {
510 this[_currentExpansion] = null;
511 this[_currentExpansion] = dart.as(dart.dinvokef(this[_f], this[_iter ator].current).iterator, core.Iterator$(T));
512 } else {
513 return false;
514 }
515 }
516 this[_current] = this[_currentExpansion].current;
517 return true;
518 }
519 }
520 return ExpandIterator;
521 });
522 let ExpandIterator = ExpandIterator$(dart.dynamic, dart.dynamic);
523 let _takeCount = Symbol('_takeCount');
524 let TakeIterable$ = dart.generic(function(E) {
525 class TakeIterable extends collection.IterableBase$(E) {
526 TakeIterable(iterable, takeCount) {
527 if (dart.notNull(!(typeof takeCount == number)) || dart.notNull(takeCoun t) < 0) {
528 throw new core.ArgumentError(takeCount);
529 }
530 if (dart.is(iterable, EfficientLength)) {
531 return new EfficientLengthTakeIterable(iterable, takeCount);
532 }
533 return new TakeIterable._(iterable, takeCount);
534 }
535 TakeIterable$_($_iterable, $_takeCount) {
536 this[_iterable] = $_iterable;
537 this[_takeCount] = $_takeCount;
538 super.IterableBase();
539 }
540 get iterator() {
541 return new TakeIterator(this[_iterable].iterator, this[_takeCount]);
542 }
543 }
544 dart.defineNamedConstructor(TakeIterable, '_');
545 return TakeIterable;
546 });
547 let TakeIterable = TakeIterable$(dart.dynamic);
548 let EfficientLengthTakeIterable$ = dart.generic(function(E) {
549 class EfficientLengthTakeIterable extends TakeIterable$(E) {
550 EfficientLengthTakeIterable(iterable, takeCount) {
551 super.TakeIterable$_(iterable, takeCount);
552 }
553 get length() {
554 let iterableLength = this[_iterable].length;
555 if (dart.notNull(iterableLength) > dart.notNull(this[_takeCount]))
556 return this[_takeCount];
557 return iterableLength;
558 }
559 }
560 return EfficientLengthTakeIterable;
561 });
562 let EfficientLengthTakeIterable = EfficientLengthTakeIterable$(dart.dynamic);
563 let _remaining = Symbol('_remaining');
564 let TakeIterator$ = dart.generic(function(E) {
565 class TakeIterator extends core.Iterator$(E) {
566 TakeIterator($_iterator, $_remaining) {
567 this[_iterator] = $_iterator;
568 this[_remaining] = $_remaining;
569 super.Iterator();
570 dart.assert(dart.notNull(typeof this[_remaining] == number) && dart.notN ull(this[_remaining]) >= 0);
571 }
572 moveNext() {
573 this[_remaining] = dart.notNull(this[_remaining]) - 1;
574 if (dart.notNull(this[_remaining]) >= 0) {
575 return this[_iterator].moveNext();
576 }
577 this[_remaining] = -1;
578 return false;
579 }
580 get current() {
581 if (dart.notNull(this[_remaining]) < 0)
582 return null;
583 return this[_iterator].current;
584 }
585 }
586 return TakeIterator;
587 });
588 let TakeIterator = TakeIterator$(dart.dynamic);
589 let TakeWhileIterable$ = dart.generic(function(E) {
590 class TakeWhileIterable extends collection.IterableBase$(E) {
591 TakeWhileIterable($_iterable, $_f) {
592 this[_iterable] = $_iterable;
593 this[_f] = $_f;
594 super.IterableBase();
595 }
596 get iterator() {
597 return new TakeWhileIterator(this[_iterable].iterator, dart.closureWrap( this[_f], "(E) → bool"));
598 }
599 }
600 return TakeWhileIterable;
601 });
602 let TakeWhileIterable = TakeWhileIterable$(dart.dynamic);
603 let _isFinished = Symbol('_isFinished');
604 let TakeWhileIterator$ = dart.generic(function(E) {
605 class TakeWhileIterator extends core.Iterator$(E) {
606 TakeWhileIterator($_iterator, $_f) {
607 this[_iterator] = $_iterator;
608 this[_f] = $_f;
609 this[_isFinished] = false;
610 super.Iterator();
611 }
612 moveNext() {
613 if (this[_isFinished])
614 return false;
615 if (!dart.notNull(this[_iterator].moveNext()) || !dart.notNull(dart.dinv okef(this[_f], this[_iterator].current))) {
616 this[_isFinished] = true;
617 return false;
618 }
619 return true;
620 }
621 get current() {
622 if (this[_isFinished])
623 return null;
624 return this[_iterator].current;
625 }
626 }
627 return TakeWhileIterator;
628 });
629 let TakeWhileIterator = TakeWhileIterator$(dart.dynamic);
630 let _skipCount = Symbol('_skipCount');
631 let SkipIterable$ = dart.generic(function(E) {
632 class SkipIterable extends collection.IterableBase$(E) {
633 SkipIterable(iterable, count) {
634 if (dart.is(iterable, EfficientLength)) {
635 return new EfficientLengthSkipIterable(iterable, count);
636 }
637 return new SkipIterable._(iterable, count);
638 }
639 SkipIterable$_($_iterable, $_skipCount) {
640 this[_iterable] = $_iterable;
641 this[_skipCount] = $_skipCount;
642 super.IterableBase();
643 if (!(typeof this[_skipCount] == number)) {
644 throw new core.ArgumentError.value(this[_skipCount], "count is not an integer");
645 }
646 core.RangeError.checkNotNegative(this[_skipCount], "count");
647 }
648 skip(count) {
649 if (!(typeof this[_skipCount] == number)) {
650 throw new core.ArgumentError.value(this[_skipCount], "count is not an integer");
651 }
652 core.RangeError.checkNotNegative(this[_skipCount], "count");
653 return new SkipIterable._(this[_iterable], dart.notNull(this[_skipCount] ) + dart.notNull(count));
654 }
655 get iterator() {
656 return new SkipIterator(this[_iterable].iterator, this[_skipCount]);
657 }
658 }
659 dart.defineNamedConstructor(SkipIterable, '_');
660 return SkipIterable;
661 });
662 let SkipIterable = SkipIterable$(dart.dynamic);
663 let EfficientLengthSkipIterable$ = dart.generic(function(E) {
664 class EfficientLengthSkipIterable extends SkipIterable$(E) {
665 EfficientLengthSkipIterable(iterable, skipCount) {
666 super.SkipIterable$_(iterable, skipCount);
667 }
668 get length() {
669 let length = dart.notNull(this[_iterable].length) - dart.notNull(this[_s kipCount]);
670 if (dart.notNull(length) >= 0)
671 return length;
672 return 0;
673 }
674 }
675 return EfficientLengthSkipIterable;
676 });
677 let EfficientLengthSkipIterable = EfficientLengthSkipIterable$(dart.dynamic);
678 let SkipIterator$ = dart.generic(function(E) {
679 class SkipIterator extends core.Iterator$(E) {
680 SkipIterator($_iterator, $_skipCount) {
681 this[_iterator] = $_iterator;
682 this[_skipCount] = $_skipCount;
683 super.Iterator();
684 dart.assert(dart.notNull(typeof this[_skipCount] == number) && dart.notN ull(this[_skipCount]) >= 0);
685 }
686 moveNext() {
687 for (let i = 0; dart.notNull(i) < dart.notNull(this[_skipCount]); i = da rt.notNull(i) + 1)
688 this[_iterator].moveNext();
689 this[_skipCount] = 0;
690 return this[_iterator].moveNext();
691 }
692 get current() {
693 return this[_iterator].current;
694 }
695 }
696 return SkipIterator;
697 });
698 let SkipIterator = SkipIterator$(dart.dynamic);
699 let SkipWhileIterable$ = dart.generic(function(E) {
700 class SkipWhileIterable extends collection.IterableBase$(E) {
701 SkipWhileIterable($_iterable, $_f) {
702 this[_iterable] = $_iterable;
703 this[_f] = $_f;
704 super.IterableBase();
705 }
706 get iterator() {
707 return new SkipWhileIterator(this[_iterable].iterator, dart.closureWrap( this[_f], "(E) → bool"));
708 }
709 }
710 return SkipWhileIterable;
711 });
712 let SkipWhileIterable = SkipWhileIterable$(dart.dynamic);
713 let _hasSkipped = Symbol('_hasSkipped');
714 let SkipWhileIterator$ = dart.generic(function(E) {
715 class SkipWhileIterator extends core.Iterator$(E) {
716 SkipWhileIterator($_iterator, $_f) {
717 this[_iterator] = $_iterator;
718 this[_f] = $_f;
719 this[_hasSkipped] = false;
720 super.Iterator();
721 }
722 moveNext() {
723 if (!dart.notNull(this[_hasSkipped])) {
724 this[_hasSkipped] = true;
725 while (this[_iterator].moveNext()) {
726 if (!dart.notNull(dart.dinvokef(this[_f], this[_iterator].current)))
727 return true;
728 }
729 }
730 return this[_iterator].moveNext();
731 }
732 get current() {
733 return this[_iterator].current;
734 }
735 }
736 return SkipWhileIterator;
737 });
738 let SkipWhileIterator = SkipWhileIterator$(dart.dynamic);
739 let EmptyIterable$ = dart.generic(function(E) {
740 class EmptyIterable extends collection.IterableBase$(E) {
741 EmptyIterable() {
742 super.IterableBase();
743 }
744 get iterator() {
745 return dart.as(new EmptyIterator(), core.Iterator$(E));
746 }
747 forEach(action) {}
748 get isEmpty() {
749 return true;
750 }
751 get length() {
752 return 0;
753 }
754 get first() {
755 throw IterableElementError.noElement();
756 }
757 get last() {
758 throw IterableElementError.noElement();
759 }
760 get single() {
761 throw IterableElementError.noElement();
762 }
763 elementAt(index) {
764 throw new core.RangeError.range(index, 0, 0, "index");
765 }
766 contains(element) {
767 return false;
768 }
769 every(test) {
770 return true;
771 }
772 any(test) {
773 return false;
774 }
775 firstWhere(test, opt$) {
776 let orElse = opt$.orElse === void 0 ? null : opt$.orElse;
777 if (orElse !== null)
778 return orElse();
779 throw IterableElementError.noElement();
780 }
781 lastWhere(test, opt$) {
782 let orElse = opt$.orElse === void 0 ? null : opt$.orElse;
783 if (orElse !== null)
784 return orElse();
785 throw IterableElementError.noElement();
786 }
787 singleWhere(test, opt$) {
788 let orElse = opt$.orElse === void 0 ? null : opt$.orElse;
789 if (orElse !== null)
790 return orElse();
791 throw IterableElementError.noElement();
792 }
793 join(separator) {
794 if (separator === void 0)
795 separator = "";
796 return "";
797 }
798 where(test) {
799 return this;
800 }
801 map(f) {
802 return new EmptyIterable();
803 }
804 reduce(combine) {
805 throw IterableElementError.noElement();
806 }
807 fold(initialValue, combine) {
808 return initialValue;
809 }
810 skip(count) {
811 core.RangeError.checkNotNegative(count, "count");
812 return this;
813 }
814 skipWhile(test) {
815 return this;
816 }
817 take(count) {
818 core.RangeError.checkNotNegative(count, "count");
819 return this;
820 }
821 takeWhile(test) {
822 return this;
823 }
824 toList(opt$) {
825 let growable = opt$.growable === void 0 ? true : opt$.growable;
826 return growable ? new List.from([]) : new core.List(0);
827 }
828 toSet() {
829 return new core.Set();
830 }
831 }
832 return EmptyIterable;
833 });
834 let EmptyIterable = EmptyIterable$(dart.dynamic);
835 let EmptyIterator$ = dart.generic(function(E) {
836 class EmptyIterator extends core.Object {
837 EmptyIterator() {
838 }
839 moveNext() {
840 return false;
841 }
842 get current() {
843 return null;
844 }
845 }
846 return EmptyIterator;
847 });
848 let EmptyIterator = EmptyIterator$(dart.dynamic);
849 let BidirectionalIterator$ = dart.generic(function(T) {
850 class BidirectionalIterator extends core.Object {
851 }
852 return BidirectionalIterator;
853 });
854 let BidirectionalIterator = BidirectionalIterator$(dart.dynamic);
855 let _rangeCheck = Symbol('_rangeCheck');
856 let IterableMixinWorkaround$ = dart.generic(function(T) {
857 class IterableMixinWorkaround extends core.Object {
858 static contains(iterable, element) {
859 for (let e of iterable) {
860 if (dart.equals(e, element))
861 return true;
862 }
863 return false;
864 }
865 static forEach(iterable, f) {
866 for (let e of iterable) {
867 dart.dinvokef(f, e);
868 }
869 }
870 static any(iterable, f) {
871 for (let e of iterable) {
872 if (dart.dinvokef(f, e))
873 return true;
874 }
875 return false;
876 }
877 static every(iterable, f) {
878 for (let e of iterable) {
879 if (!dart.notNull(dart.dinvokef(f, e)))
880 return false;
881 }
882 return true;
883 }
884 static reduce(iterable, combine) {
885 let iterator = iterable.iterator;
886 if (!dart.notNull(iterator.moveNext()))
887 throw IterableElementError.noElement();
888 let value = iterator.current;
889 while (iterator.moveNext()) {
890 value = dart.dinvokef(combine, value, iterator.current);
891 }
892 return value;
893 }
894 static fold(iterable, initialValue, combine) {
895 for (let element of iterable) {
896 initialValue = dart.dinvokef(combine, initialValue, element);
897 }
898 return initialValue;
899 }
900 static removeWhereList(list, test) {
901 let retained = new List.from([]);
902 let length = list.length;
903 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull (i) + 1) {
904 let element = list.get(i);
905 if (!dart.notNull(dart.dinvokef(test, element))) {
906 retained.add(element);
907 }
908 if (length !== list.length) {
909 throw new core.ConcurrentModificationError(list);
910 }
911 }
912 if (retained.length === length)
913 return;
914 list.length = retained.length;
915 for (let i = 0; dart.notNull(i) < dart.notNull(retained.length); i = dar t.notNull(i) + 1) {
916 list.set(i, retained.get(i));
917 }
918 }
919 static isEmpty(iterable) {
920 return !dart.notNull(iterable.iterator.moveNext());
921 }
922 static first(iterable) {
923 let it = iterable.iterator;
924 if (!dart.notNull(it.moveNext())) {
925 throw IterableElementError.noElement();
926 }
927 return it.current;
928 }
929 static last(iterable) {
930 let it = iterable.iterator;
931 if (!dart.notNull(it.moveNext())) {
932 throw IterableElementError.noElement();
933 }
934 let result = null;
935 do {
936 result = it.current;
937 } while (it.moveNext());
938 return result;
939 }
940 static single(iterable) {
941 let it = iterable.iterator;
942 if (!dart.notNull(it.moveNext()))
943 throw IterableElementError.noElement();
944 let result = it.current;
945 if (it.moveNext())
946 throw IterableElementError.tooMany();
947 return result;
948 }
949 static firstWhere(iterable, test, orElse) {
950 for (let element of iterable) {
951 if (dart.dinvokef(test, element))
952 return element;
953 }
954 if (orElse !== null)
955 return orElse();
956 throw IterableElementError.noElement();
957 }
958 static lastWhere(iterable, test, orElse) {
959 let result = null;
960 let foundMatching = false;
961 for (let element of iterable) {
962 if (dart.dinvokef(test, element)) {
963 result = element;
964 foundMatching = true;
965 }
966 }
967 if (foundMatching)
968 return result;
969 if (orElse !== null)
970 return orElse();
971 throw IterableElementError.noElement();
972 }
973 static lastWhereList(list, test, orElse) {
974 for (let i = dart.notNull(list.length) - 1; dart.notNull(i) >= 0; i = da rt.notNull(i) - 1) {
975 let element = list.get(i);
976 if (dart.dinvokef(test, element))
977 return element;
978 }
979 if (orElse !== null)
980 return orElse();
981 throw IterableElementError.noElement();
982 }
983 static singleWhere(iterable, test) {
984 let result = null;
985 let foundMatching = false;
986 for (let element of iterable) {
987 if (dart.dinvokef(test, element)) {
988 if (foundMatching) {
989 throw IterableElementError.tooMany();
990 }
991 result = element;
992 foundMatching = true;
993 }
994 }
995 if (foundMatching)
996 return result;
997 throw IterableElementError.noElement();
998 }
999 static elementAt(iterable, index) {
1000 if (!(typeof index == number))
1001 throw new core.ArgumentError.notNull("index");
1002 core.RangeError.checkNotNegative(index, "index");
1003 let elementIndex = 0;
1004 for (let element of iterable) {
1005 if (index === elementIndex)
1006 return element;
1007 elementIndex = dart.notNull(elementIndex) + 1;
1008 }
1009 throw new core.RangeError.index(index, iterable, "index", null, elementI ndex);
1010 }
1011 static join(iterable, separator) {
1012 if (separator === void 0)
1013 separator = null;
1014 let buffer = new core.StringBuffer();
1015 buffer.writeAll(iterable, separator);
1016 return buffer.toString();
1017 }
1018 static joinList(list, separator) {
1019 if (separator === void 0)
1020 separator = null;
1021 if (list.isEmpty)
1022 return "";
1023 if (list.length === 1)
1024 return `${list.get(0)}`;
1025 let buffer = new core.StringBuffer();
1026 if (separator.isEmpty) {
1027 for (let i = 0; dart.notNull(i) < dart.notNull(list.length); i = dart. notNull(i) + 1) {
1028 buffer.write(list.get(i));
1029 }
1030 } else {
1031 buffer.write(list.get(0));
1032 for (let i = 1; dart.notNull(i) < dart.notNull(list.length); i = dart. notNull(i) + 1) {
1033 buffer.write(separator);
1034 buffer.write(list.get(i));
1035 }
1036 }
1037 return buffer.toString();
1038 }
1039 where(iterable, f) {
1040 return new WhereIterable(dart.as(iterable, core.Iterable$(T)), dart.clos ureWrap(f, "(T) → bool"));
1041 }
1042 static map(iterable, f) {
1043 return new MappedIterable(iterable, f);
1044 }
1045 static mapList(list, f) {
1046 return new MappedListIterable(list, f);
1047 }
1048 static expand(iterable, f) {
1049 return new ExpandIterable(iterable, f);
1050 }
1051 takeList(list, n) {
1052 return new SubListIterable(dart.as(list, core.Iterable$(T)), 0, n);
1053 }
1054 takeWhile(iterable, test) {
1055 return new TakeWhileIterable(dart.as(iterable, core.Iterable$(T)), dart. closureWrap(test, "(T) → bool"));
1056 }
1057 skipList(list, n) {
1058 return new SubListIterable(dart.as(list, core.Iterable$(T)), n, null);
1059 }
1060 skipWhile(iterable, test) {
1061 return new SkipWhileIterable(dart.as(iterable, core.Iterable$(T)), dart. closureWrap(test, "(T) → bool"));
1062 }
1063 reversedList(list) {
1064 return new ReversedListIterable(dart.as(list, core.Iterable$(T)));
1065 }
1066 static sortList(list, compare) {
1067 if (compare === null)
1068 compare = core.Comparable.compare;
1069 Sort.sort(list, compare);
1070 }
1071 static shuffleList(list, random) {
1072 if (random === null)
1073 random = new math.Random();
1074 let length = list.length;
1075 while (dart.notNull(length) > 1) {
1076 let pos = random.nextInt(length);
1077 length = 1;
1078 let tmp = list.get(length);
1079 list.set(length, list.get(pos));
1080 list.set(pos, tmp);
1081 }
1082 }
1083 static indexOfList(list, element, start) {
1084 return Lists.indexOf(list, element, start, list.length);
1085 }
1086 static lastIndexOfList(list, element, start) {
1087 if (start === null)
1088 start = dart.notNull(list.length) - 1;
1089 return Lists.lastIndexOf(list, element, start);
1090 }
1091 static [_rangeCheck](list, start, end) {
1092 core.RangeError.checkValidRange(start, end, list.length);
1093 }
1094 getRangeList(list, start, end) {
1095 _rangeCheck(list, start, end);
1096 return new SubListIterable(dart.as(list, core.Iterable$(T)), start, end) ;
1097 }
1098 static setRangeList(list, start, end, from, skipCount) {
1099 _rangeCheck(list, start, end);
1100 let length = dart.notNull(end) - dart.notNull(start);
1101 if (length === 0)
1102 return;
1103 if (dart.notNull(skipCount) < 0)
1104 throw new core.ArgumentError(skipCount);
1105 let otherList = null;
1106 let otherStart = null;
1107 if (dart.is(from, core.List)) {
1108 otherList = from;
1109 otherStart = skipCount;
1110 } else {
1111 otherList = from.skip(skipCount).toList({growable: false});
1112 otherStart = 0;
1113 }
1114 if (dart.notNull(otherStart) + dart.notNull(length) > dart.notNull(other List.length)) {
1115 throw IterableElementError.tooFew();
1116 }
1117 Lists.copy(otherList, otherStart, list, start, length);
1118 }
1119 static replaceRangeList(list, start, end, iterable) {
1120 _rangeCheck(list, start, end);
1121 if (!dart.is(iterable, EfficientLength)) {
1122 iterable = iterable.toList();
1123 }
1124 let removeLength = dart.notNull(end) - dart.notNull(start);
1125 let insertLength = iterable.length;
1126 if (dart.notNull(removeLength) >= dart.notNull(insertLength)) {
1127 let delta = dart.notNull(removeLength) - dart.notNull(insertLength);
1128 let insertEnd = dart.notNull(start) + dart.notNull(insertLength);
1129 let newEnd = dart.notNull(list.length) - dart.notNull(delta);
1130 list.setRange(start, insertEnd, iterable);
1131 if (delta !== 0) {
1132 list.setRange(insertEnd, newEnd, list, end);
1133 list.length = newEnd;
1134 }
1135 } else {
1136 let delta = dart.notNull(insertLength) - dart.notNull(removeLength);
1137 let newLength = dart.notNull(list.length) + dart.notNull(delta);
1138 let insertEnd = dart.notNull(start) + dart.notNull(insertLength);
1139 list.length = newLength;
1140 list.setRange(insertEnd, newLength, list, end);
1141 list.setRange(start, insertEnd, iterable);
1142 }
1143 }
1144 static fillRangeList(list, start, end, fillValue) {
1145 _rangeCheck(list, start, end);
1146 for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNul l(i) + 1) {
1147 list.set(i, fillValue);
1148 }
1149 }
1150 static insertAllList(list, index, iterable) {
1151 core.RangeError.checkValueInInterval(index, 0, list.length, "index");
1152 if (!dart.is(iterable, EfficientLength)) {
1153 iterable = iterable.toList({growable: false});
1154 }
1155 let insertionLength = iterable.length;
1156 list.length = insertionLength;
1157 list.setRange(dart.notNull(index) + dart.notNull(insertionLength), list. length, list, index);
1158 for (let element of iterable) {
1159 list.set((($tmp) => index = dart.notNull($tmp) + 1, $tmp)(index), elem ent);
1160 }
1161 }
1162 static setAllList(list, index, iterable) {
1163 core.RangeError.checkValueInInterval(index, 0, list.length, "index");
1164 for (let element of iterable) {
1165 list.set((($tmp) => index = dart.notNull($tmp) + 1, $tmp)(index), elem ent);
1166 }
1167 }
1168 asMapList(l) {
1169 return new ListMapView(dart.as(l, core.List$(T)));
1170 }
1171 static setContainsAll(set, other) {
1172 for (let element of other) {
1173 if (!dart.notNull(set.contains(element)))
1174 return false;
1175 }
1176 return true;
1177 }
1178 static setIntersection(set, other, result) {
1179 let smaller = null;
1180 let larger = null;
1181 if (dart.notNull(set.length) < dart.notNull(other.length)) {
1182 smaller = set;
1183 larger = other;
1184 } else {
1185 smaller = other;
1186 larger = set;
1187 }
1188 for (let element of smaller) {
1189 if (larger.contains(element)) {
1190 result.add(element);
1191 }
1192 }
1193 return result;
1194 }
1195 static setUnion(set, other, result) {
1196 result.addAll(set);
1197 result.addAll(other);
1198 return result;
1199 }
1200 static setDifference(set, other, result) {
1201 for (let element of set) {
1202 if (!dart.notNull(other.contains(element))) {
1203 result.add(element);
1204 }
1205 }
1206 return result;
1207 }
1208 }
1209 return IterableMixinWorkaround;
1210 });
1211 let IterableMixinWorkaround = IterableMixinWorkaround$(dart.dynamic);
1212 class IterableElementError extends core.Object {
1213 static noElement() {
1214 return new core.StateError("No element");
1215 }
1216 static tooMany() {
1217 return new core.StateError("Too many elements");
1218 }
1219 static tooFew() {
1220 return new core.StateError("Too few elements");
1221 }
1222 }
1223 let FixedLengthListMixin$ = dart.generic(function(E) {
1224 class FixedLengthListMixin extends core.Object {
1225 set length(newLength) {
1226 throw new core.UnsupportedError("Cannot change the length of a fixed-len gth list");
1227 }
1228 add(value) {
1229 throw new core.UnsupportedError("Cannot add to a fixed-length list");
1230 }
1231 insert(index, value) {
1232 throw new core.UnsupportedError("Cannot add to a fixed-length list");
1233 }
1234 insertAll(at, iterable) {
1235 throw new core.UnsupportedError("Cannot add to a fixed-length list");
1236 }
1237 addAll(iterable) {
1238 throw new core.UnsupportedError("Cannot add to a fixed-length list");
1239 }
1240 remove(element) {
1241 throw new core.UnsupportedError("Cannot remove from a fixed-length list" );
1242 }
1243 removeWhere(test) {
1244 throw new core.UnsupportedError("Cannot remove from a fixed-length list" );
1245 }
1246 retainWhere(test) {
1247 throw new core.UnsupportedError("Cannot remove from a fixed-length list" );
1248 }
1249 clear() {
1250 throw new core.UnsupportedError("Cannot clear a fixed-length list");
1251 }
1252 removeAt(index) {
1253 throw new core.UnsupportedError("Cannot remove from a fixed-length list" );
1254 }
1255 removeLast() {
1256 throw new core.UnsupportedError("Cannot remove from a fixed-length list" );
1257 }
1258 removeRange(start, end) {
1259 throw new core.UnsupportedError("Cannot remove from a fixed-length list" );
1260 }
1261 replaceRange(start, end, iterable) {
1262 throw new core.UnsupportedError("Cannot remove from a fixed-length list" );
1263 }
1264 }
1265 return FixedLengthListMixin;
1266 });
1267 let FixedLengthListMixin = FixedLengthListMixin$(dart.dynamic);
1268 let UnmodifiableListMixin$ = dart.generic(function(E) {
1269 class UnmodifiableListMixin extends core.Object {
1270 set(index, value) {
1271 throw new core.UnsupportedError("Cannot modify an unmodifiable list");
1272 }
1273 set length(newLength) {
1274 throw new core.UnsupportedError("Cannot change the length of an unmodifi able list");
1275 }
1276 setAll(at, iterable) {
1277 throw new core.UnsupportedError("Cannot modify an unmodifiable list");
1278 }
1279 add(value) {
1280 throw new core.UnsupportedError("Cannot add to an unmodifiable list");
1281 }
1282 insert(index, value) {
1283 throw new core.UnsupportedError("Cannot add to an unmodifiable list");
1284 }
1285 insertAll(at, iterable) {
1286 throw new core.UnsupportedError("Cannot add to an unmodifiable list");
1287 }
1288 addAll(iterable) {
1289 throw new core.UnsupportedError("Cannot add to an unmodifiable list");
1290 }
1291 remove(element) {
1292 throw new core.UnsupportedError("Cannot remove from an unmodifiable list ");
1293 }
1294 removeWhere(test) {
1295 throw new core.UnsupportedError("Cannot remove from an unmodifiable list ");
1296 }
1297 retainWhere(test) {
1298 throw new core.UnsupportedError("Cannot remove from an unmodifiable list ");
1299 }
1300 sort(compare) {
1301 if (compare === void 0)
1302 compare = null;
1303 throw new core.UnsupportedError("Cannot modify an unmodifiable list");
1304 }
1305 shuffle(random) {
1306 if (random === void 0)
1307 random = null;
1308 throw new core.UnsupportedError("Cannot modify an unmodifiable list");
1309 }
1310 clear() {
1311 throw new core.UnsupportedError("Cannot clear an unmodifiable list");
1312 }
1313 removeAt(index) {
1314 throw new core.UnsupportedError("Cannot remove from an unmodifiable list ");
1315 }
1316 removeLast() {
1317 throw new core.UnsupportedError("Cannot remove from an unmodifiable list ");
1318 }
1319 setRange(start, end, iterable, skipCount) {
1320 if (skipCount === void 0)
1321 skipCount = 0;
1322 throw new core.UnsupportedError("Cannot modify an unmodifiable list");
1323 }
1324 removeRange(start, end) {
1325 throw new core.UnsupportedError("Cannot remove from an unmodifiable list ");
1326 }
1327 replaceRange(start, end, iterable) {
1328 throw new core.UnsupportedError("Cannot remove from an unmodifiable list ");
1329 }
1330 fillRange(start, end, fillValue) {
1331 if (fillValue === void 0)
1332 fillValue = null;
1333 throw new core.UnsupportedError("Cannot modify an unmodifiable list");
1334 }
1335 }
1336 return UnmodifiableListMixin;
1337 });
1338 let UnmodifiableListMixin = UnmodifiableListMixin$(dart.dynamic);
1339 let FixedLengthListBase$ = dart.generic(function(E) {
1340 class FixedLengthListBase extends dart.mixin(FixedLengthListMixin$(E)) {
1341 }
1342 return FixedLengthListBase;
1343 });
1344 let FixedLengthListBase = FixedLengthListBase$(dart.dynamic);
1345 let UnmodifiableListBase$ = dart.generic(function(E) {
1346 class UnmodifiableListBase extends dart.mixin(UnmodifiableListMixin$(E)) {
1347 }
1348 return UnmodifiableListBase;
1349 });
1350 let UnmodifiableListBase = UnmodifiableListBase$(dart.dynamic);
1351 let _backedList = Symbol('_backedList');
1352 class _ListIndicesIterable extends ListIterable$(core.int) {
1353 _ListIndicesIterable($_backedList) {
1354 this[_backedList] = $_backedList;
1355 super.ListIterable();
1356 }
1357 get length() {
1358 return this[_backedList].length;
1359 }
1360 elementAt(index) {
1361 core.RangeError.checkValidIndex(index, this);
1362 return index;
1363 }
1364 }
1365 let _values = Symbol('_values');
1366 let ListMapView$ = dart.generic(function(E) {
1367 class ListMapView extends core.Object {
1368 ListMapView($_values) {
1369 this[_values] = $_values;
1370 }
1371 get(key) {
1372 return this.containsKey(key) ? this[_values].get(key) : null;
1373 }
1374 get length() {
1375 return this[_values].length;
1376 }
1377 get values() {
1378 return new SubListIterable(this[_values], 0, null);
1379 }
1380 get keys() {
1381 return new _ListIndicesIterable(this[_values]);
1382 }
1383 get isEmpty() {
1384 return this[_values].isEmpty;
1385 }
1386 get isNotEmpty() {
1387 return this[_values].isNotEmpty;
1388 }
1389 containsValue(value) {
1390 return this[_values].contains(value);
1391 }
1392 containsKey(key) {
1393 return dart.notNull(typeof key == number) && dart.notNull(key) >= 0 && d art.notNull(key) < dart.notNull(this.length);
1394 }
1395 forEach(f) {
1396 let length = this[_values].length;
1397 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull (i) + 1) {
1398 f(i, this[_values].get(i));
1399 if (length !== this[_values].length) {
1400 throw new core.ConcurrentModificationError(this[_values]);
1401 }
1402 }
1403 }
1404 set(key, value) {
1405 throw new core.UnsupportedError("Cannot modify an unmodifiable map");
1406 }
1407 putIfAbsent(key, ifAbsent) {
1408 throw new core.UnsupportedError("Cannot modify an unmodifiable map");
1409 }
1410 remove(key) {
1411 throw new core.UnsupportedError("Cannot modify an unmodifiable map");
1412 }
1413 clear() {
1414 throw new core.UnsupportedError("Cannot modify an unmodifiable map");
1415 }
1416 addAll(other) {
1417 throw new core.UnsupportedError("Cannot modify an unmodifiable map");
1418 }
1419 toString() {
1420 return collection.Maps.mapToString(this);
1421 }
1422 }
1423 return ListMapView;
1424 });
1425 let ListMapView = ListMapView$(dart.dynamic);
1426 let ReversedListIterable$ = dart.generic(function(E) {
1427 class ReversedListIterable extends ListIterable$(E) {
1428 ReversedListIterable($_source) {
1429 this[_source] = $_source;
1430 super.ListIterable();
1431 }
1432 get length() {
1433 return this[_source].length;
1434 }
1435 elementAt(index) {
1436 return this[_source].elementAt(dart.notNull(this[_source].length) - 1 - dart.notNull(index));
1437 }
1438 }
1439 return ReversedListIterable;
1440 });
1441 let ReversedListIterable = ReversedListIterable$(dart.dynamic);
1442 class UnmodifiableListError extends core.Object {
1443 static add() {
1444 return new core.UnsupportedError("Cannot add to unmodifiable List");
1445 }
1446 static change() {
1447 return new core.UnsupportedError("Cannot change the content of an unmodifi able List");
1448 }
1449 static length() {
1450 return new core.UnsupportedError("Cannot change length of unmodifiable Lis t");
1451 }
1452 static remove() {
1453 return new core.UnsupportedError("Cannot remove from unmodifiable List");
1454 }
1455 }
1456 class NonGrowableListError extends core.Object {
1457 static add() {
1458 return new core.UnsupportedError("Cannot add to non-growable List");
1459 }
1460 static length() {
1461 return new core.UnsupportedError("Cannot change length of non-growable Lis t");
1462 }
1463 static remove() {
1464 return new core.UnsupportedError("Cannot remove from non-growable List");
1465 }
1466 }
1467 // Function makeListFixedLength: (List<dynamic>) → List
1468 function makeListFixedLength(growableList) {
1469 _interceptors.JSArray.markFixedList(growableList);
1470 return growableList;
1471 }
1472 class Lists extends core.Object {
1473 static copy(src, srcStart, dst, dstStart, count) {
1474 if (dart.notNull(srcStart) < dart.notNull(dstStart)) {
1475 for (let i = dart.notNull(srcStart) + dart.notNull(count) - 1, j = dart. notNull(dstStart) + dart.notNull(count) - 1; dart.notNull(i) >= dart.notNull(src Start); i = dart.notNull(i) - 1, j = dart.notNull(j) - 1) {
1476 dst.set(j, src.get(i));
1477 }
1478 } else {
1479 for (let i = srcStart, j = dstStart; dart.notNull(i) < dart.notNull(srcS tart) + dart.notNull(count); i = dart.notNull(i) + 1, j = dart.notNull(j) + 1) {
1480 dst.set(j, src.get(i));
1481 }
1482 }
1483 }
1484 static areEqual(a, b) {
1485 if (core.identical(a, b))
1486 return true;
1487 if (!dart.notNull(dart.is(b, core.List)))
1488 return false;
1489 let length = a.length;
1490 if (length !== dart.dload(b, 'length'))
1491 return false;
1492 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i ) + 1) {
1493 if (!dart.notNull(core.identical(a.get(i), dart.dindex(b, i))))
1494 return false;
1495 }
1496 return true;
1497 }
1498 static indexOf(a, element, startIndex, endIndex) {
1499 if (dart.notNull(startIndex) >= dart.notNull(a.length)) {
1500 return -1;
1501 }
1502 if (dart.notNull(startIndex) < 0) {
1503 startIndex = 0;
1504 }
1505 for (let i = startIndex; dart.notNull(i) < dart.notNull(endIndex); i = dar t.notNull(i) + 1) {
1506 if (dart.equals(a.get(i), element)) {
1507 return i;
1508 }
1509 }
1510 return -1;
1511 }
1512 static lastIndexOf(a, element, startIndex) {
1513 if (dart.notNull(startIndex) < 0) {
1514 return -1;
1515 }
1516 if (dart.notNull(startIndex) >= dart.notNull(a.length)) {
1517 startIndex = dart.notNull(a.length) - 1;
1518 }
1519 for (let i = startIndex; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
1520 if (dart.equals(a.get(i), element)) {
1521 return i;
1522 }
1523 }
1524 return -1;
1525 }
1526 static indicesCheck(a, start, end) {
1527 core.RangeError.checkValidRange(start, end, a.length);
1528 }
1529 static rangeCheck(a, start, length) {
1530 core.RangeError.checkNotNegative(length);
1531 core.RangeError.checkNotNegative(start);
1532 if (dart.notNull(start) + dart.notNull(length) > dart.notNull(a.length)) {
1533 let message = `${start} + ${length} must be in the range [0..${a.length} ]`;
1534 throw new core.RangeError.range(length, 0, dart.notNull(a.length) - dart .notNull(start), "length", message);
1535 }
1536 }
1537 }
1538 exports.printToZone = null;
1539 // Function printToConsole: (String) → void
1540 function printToConsole(line) {
1541 _js_primitives.printString(`${line}`);
1542 }
1543 let _doSort = Symbol('_doSort');
1544 let _insertionSort = Symbol('_insertionSort');
1545 let _dualPivotQuicksort = Symbol('_dualPivotQuicksort');
1546 class Sort extends core.Object {
1547 static sort(a, compare) {
1548 _doSort(a, 0, dart.notNull(a.length) - 1, compare);
1549 }
1550 static sortRange(a, from, to, compare) {
1551 if (dart.notNull(from) < 0 || dart.notNull(to) > dart.notNull(a.length) || dart.notNull(to) < dart.notNull(from)) {
1552 throw "OutOfRange";
1553 }
1554 _doSort(a, from, dart.notNull(to) - 1, compare);
1555 }
1556 static [_doSort](a, left, right, compare) {
1557 if (dart.notNull(right) - dart.notNull(left) <= dart.notNull(Sort._INSERTI ON_SORT_THRESHOLD)) {
1558 _insertionSort(a, left, right, compare);
1559 } else {
1560 _dualPivotQuicksort(a, left, right, compare);
1561 }
1562 }
1563 static [_insertionSort](a, left, right, compare) {
1564 for (let i = dart.notNull(left) + 1; dart.notNull(i) <= dart.notNull(right ); i = dart.notNull(i) + 1) {
1565 let el = a.get(i);
1566 let j = i;
1567 while (dart.notNull(j) > dart.notNull(left) && dart.notNull(dart.dinvoke f(compare, a.get(dart.notNull(j) - 1), el)) > 0) {
1568 a.set(j, a.get(dart.notNull(j) - 1));
1569 j = dart.notNull(j) - 1;
1570 }
1571 a.set(j, el);
1572 }
1573 }
1574 static [_dualPivotQuicksort](a, left, right, compare) {
1575 dart.assert(dart.notNull(right) - dart.notNull(left) > dart.notNull(Sort._ INSERTION_SORT_THRESHOLD));
1576 let sixth = ((dart.notNull(right) - dart.notNull(left) + 1) / 6).truncate( );
1577 let index1 = dart.notNull(left) + dart.notNull(sixth);
1578 let index5 = dart.notNull(right) - dart.notNull(sixth);
1579 let index3 = ((dart.notNull(left) + dart.notNull(right)) / 2).truncate();
1580 let index2 = dart.notNull(index3) - dart.notNull(sixth);
1581 let index4 = dart.notNull(index3) + dart.notNull(sixth);
1582 let el1 = a.get(index1);
1583 let el2 = a.get(index2);
1584 let el3 = a.get(index3);
1585 let el4 = a.get(index4);
1586 let el5 = a.get(index5);
1587 if (dart.notNull(dart.dinvokef(compare, el1, el2)) > 0) {
1588 let t = el1;
1589 el1 = el2;
1590 el2 = t;
1591 }
1592 if (dart.notNull(dart.dinvokef(compare, el4, el5)) > 0) {
1593 let t = el4;
1594 el4 = el5;
1595 el5 = t;
1596 }
1597 if (dart.notNull(dart.dinvokef(compare, el1, el3)) > 0) {
1598 let t = el1;
1599 el1 = el3;
1600 el3 = t;
1601 }
1602 if (dart.notNull(dart.dinvokef(compare, el2, el3)) > 0) {
1603 let t = el2;
1604 el2 = el3;
1605 el3 = t;
1606 }
1607 if (dart.notNull(dart.dinvokef(compare, el1, el4)) > 0) {
1608 let t = el1;
1609 el1 = el4;
1610 el4 = t;
1611 }
1612 if (dart.notNull(dart.dinvokef(compare, el3, el4)) > 0) {
1613 let t = el3;
1614 el3 = el4;
1615 el4 = t;
1616 }
1617 if (dart.notNull(dart.dinvokef(compare, el2, el5)) > 0) {
1618 let t = el2;
1619 el2 = el5;
1620 el5 = t;
1621 }
1622 if (dart.notNull(dart.dinvokef(compare, el2, el3)) > 0) {
1623 let t = el2;
1624 el2 = el3;
1625 el3 = t;
1626 }
1627 if (dart.notNull(dart.dinvokef(compare, el4, el5)) > 0) {
1628 let t = el4;
1629 el4 = el5;
1630 el5 = t;
1631 }
1632 let pivot1 = el2;
1633 let pivot2 = el4;
1634 a.set(index1, el1);
1635 a.set(index3, el3);
1636 a.set(index5, el5);
1637 a.set(index2, a.get(left));
1638 a.set(index4, a.get(right));
1639 let less = dart.notNull(left) + 1;
1640 let great = dart.notNull(right) - 1;
1641 let pivots_are_equal = dart.dinvokef(compare, pivot1, pivot2) === 0;
1642 if (pivots_are_equal) {
1643 let pivot = pivot1;
1644 for (let k = less; dart.notNull(k) <= dart.notNull(great); k = dart.notN ull(k) + 1) {
1645 let ak = a.get(k);
1646 let comp = dart.dinvokef(compare, ak, pivot);
1647 if (comp === 0)
1648 continue;
1649 if (dart.notNull(comp) < 0) {
1650 if (k !== less) {
1651 a.set(k, a.get(less));
1652 a.set(less, ak);
1653 }
1654 less = dart.notNull(less) + 1;
1655 } else {
1656 while (true) {
1657 comp = dart.dinvokef(compare, a.get(great), pivot);
1658 if (dart.notNull(comp) > 0) {
1659 great = dart.notNull(great) - 1;
1660 continue;
1661 } else if (dart.notNull(comp) < 0) {
1662 a.set(k, a.get(less));
1663 a.set((($tmp) => less = dart.notNull($tmp) + 1, $tmp)(less), a.g et(great));
1664 a.set((($tmp) => great = dart.notNull($tmp) - 1, $tmp)(great), a k);
1665 break;
1666 } else {
1667 a.set(k, a.get(great));
1668 a.set((($tmp) => great = dart.notNull($tmp) - 1, $tmp)(great), a k);
1669 break;
1670 }
1671 }
1672 }
1673 }
1674 } else {
1675 for (let k = less; dart.notNull(k) <= dart.notNull(great); k = dart.notN ull(k) + 1) {
1676 let ak = a.get(k);
1677 let comp_pivot1 = dart.dinvokef(compare, ak, pivot1);
1678 if (dart.notNull(comp_pivot1) < 0) {
1679 if (k !== less) {
1680 a.set(k, a.get(less));
1681 a.set(less, ak);
1682 }
1683 less = dart.notNull(less) + 1;
1684 } else {
1685 let comp_pivot2 = dart.dinvokef(compare, ak, pivot2);
1686 if (dart.notNull(comp_pivot2) > 0) {
1687 while (true) {
1688 let comp = dart.dinvokef(compare, a.get(great), pivot2);
1689 if (dart.notNull(comp) > 0) {
1690 great = dart.notNull(great) - 1;
1691 if (dart.notNull(great) < dart.notNull(k))
1692 break;
1693 continue;
1694 } else {
1695 comp = dart.dinvokef(compare, a.get(great), pivot1);
1696 if (dart.notNull(comp) < 0) {
1697 a.set(k, a.get(less));
1698 a.set((($tmp) => less = dart.notNull($tmp) + 1, $tmp)(less), a.get(great));
1699 a.set((($tmp) => great = dart.notNull($tmp) - 1, $tmp)(great ), ak);
1700 } else {
1701 a.set(k, a.get(great));
1702 a.set((($tmp) => great = dart.notNull($tmp) - 1, $tmp)(great ), ak);
1703 }
1704 break;
1705 }
1706 }
1707 }
1708 }
1709 }
1710 }
1711 a.set(left, a.get(dart.notNull(less) - 1));
1712 a.set(dart.notNull(less) - 1, pivot1);
1713 a.set(right, a.get(dart.notNull(great) + 1));
1714 a.set(dart.notNull(great) + 1, pivot2);
1715 _doSort(a, left, dart.notNull(less) - 2, compare);
1716 _doSort(a, dart.notNull(great) + 2, right, compare);
1717 if (pivots_are_equal) {
1718 return;
1719 }
1720 if (dart.notNull(less) < dart.notNull(index1) && dart.notNull(great) > dar t.notNull(index5)) {
1721 while (dart.dinvokef(compare, a.get(less), pivot1) === 0) {
1722 less = dart.notNull(less) + 1;
1723 }
1724 while (dart.dinvokef(compare, a.get(great), pivot2) === 0) {
1725 great = dart.notNull(great) - 1;
1726 }
1727 for (let k = less; dart.notNull(k) <= dart.notNull(great); k = dart.notN ull(k) + 1) {
1728 let ak = a.get(k);
1729 let comp_pivot1 = dart.dinvokef(compare, ak, pivot1);
1730 if (comp_pivot1 === 0) {
1731 if (k !== less) {
1732 a.set(k, a.get(less));
1733 a.set(less, ak);
1734 }
1735 less = dart.notNull(less) + 1;
1736 } else {
1737 let comp_pivot2 = dart.dinvokef(compare, ak, pivot2);
1738 if (comp_pivot2 === 0) {
1739 while (true) {
1740 let comp = dart.dinvokef(compare, a.get(great), pivot2);
1741 if (comp === 0) {
1742 great = dart.notNull(great) - 1;
1743 if (dart.notNull(great) < dart.notNull(k))
1744 break;
1745 continue;
1746 } else {
1747 comp = dart.dinvokef(compare, a.get(great), pivot1);
1748 if (dart.notNull(comp) < 0) {
1749 a.set(k, a.get(less));
1750 a.set((($tmp) => less = dart.notNull($tmp) + 1, $tmp)(less), a.get(great));
1751 a.set((($tmp) => great = dart.notNull($tmp) - 1, $tmp)(great ), ak);
1752 } else {
1753 a.set(k, a.get(great));
1754 a.set((($tmp) => great = dart.notNull($tmp) - 1, $tmp)(great ), ak);
1755 }
1756 break;
1757 }
1758 }
1759 }
1760 }
1761 }
1762 _doSort(a, less, great, compare);
1763 } else {
1764 _doSort(a, less, great, compare);
1765 }
1766 }
1767 }
1768 Sort._INSERTION_SORT_THRESHOLD = 32;
1769 let _name = Symbol('_name');
1770 class Symbol extends core.Object {
1771 Symbol(name) {
1772 this[_name] = name;
1773 }
1774 Symbol$unvalidated($_name) {
1775 this[_name] = $_name;
1776 }
1777 Symbol$validated(name) {
1778 this[_name] = validatePublicSymbol(name);
1779 }
1780 ['=='](other) {
1781 return dart.notNull(dart.is(other, Symbol)) && dart.notNull(dart.equals(th is[_name], dart.dload(other, '_name')));
1782 }
1783 get hashCode() {
1784 let arbitraryPrime = 664597;
1785 return 536870911 & dart.notNull(arbitraryPrime) * dart.notNull(this[_name] .hashCode);
1786 }
1787 toString() {
1788 return `Symbol("${this[_name]}")`;
1789 }
1790 static getName(symbol) {
1791 return symbol[_name];
1792 }
1793 static validatePublicSymbol(name) {
1794 if (dart.notNull(name.isEmpty) || dart.notNull(publicSymbolPattern.hasMatc h(name)))
1795 return name;
1796 if (name.startsWith('_')) {
1797 throw new core.ArgumentError(`"${name}" is a private identifier`);
1798 }
1799 throw new core.ArgumentError(`"${name}" is not a valid (qualified) symbol name`);
1800 }
1801 static isValidSymbol(name) {
1802 return dart.notNull(name.isEmpty) || dart.notNull(symbolPattern.hasMatch(n ame));
1803 }
1804 }
1805 dart.defineNamedConstructor(Symbol, 'unvalidated');
1806 dart.defineNamedConstructor(Symbol, 'validated');
1807 Symbol.reservedWordRE = '(?:assert|break|c(?:a(?:se|tch)|lass|on(?:st|tinue))| d(?:efault|o)|' + 'e(?:lse|num|xtends)|f(?:alse|inal(?:ly)?|or)|i[fns]|n(?:ew|ul l)|' + 'ret(?:hrow|urn)|s(?:uper|witch)|t(?:h(?:is|row)|r(?:ue|y))|' + 'v(?:ar|o id)|w(?:hile|ith))';
1808 Symbol.publicIdentifierRE = '(?!' + `${Symbol.reservedWordRE}` + '\\b(?!\\$))[ a-zA-Z$][\\w$]*';
1809 Symbol.identifierRE = '(?!' + `${Symbol.reservedWordRE}` + '\\b(?!\\$))[a-zA-Z $_][\\w$]*';
1810 Symbol.operatorRE = '(?:[\\-+*/%&|^]|\\[\\]=?|==|~/?|<[<=]?|>[>=]?|unary-)';
1811 dart.defineLazyProperties(Symbol, {
1812 get publicSymbolPattern() {
1813 return new core.RegExp(`^(?:${Symbol.operatorRE}$|${Symbol.publicIdentifie rRE}(?:=?$|[.](?!$)))+?$`);
1814 },
1815 get symbolPattern() {
1816 return new core.RegExp(`^(?:${Symbol.operatorRE}$|${Symbol.identifierRE}(? :=?$|[.](?!$)))+?$`);
1817 }
1818 });
1819 let POWERS_OF_TEN = /* Unimplemented const */new List.from([1.0, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0, 100 00000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0, 100000000000000.0 , 1000000000000000.0, 10000000000000000.0, 100000000000000000.0, 100000000000000 0000.0, 10000000000000000000.0, 100000000000000000000.0, 1e+21, 1e+22]);
1820 // Exports:
1821 exports.EfficientLength = EfficientLength;
1822 exports.ListIterable = ListIterable;
1823 exports.ListIterable$ = ListIterable$;
1824 exports.SubListIterable = SubListIterable;
1825 exports.SubListIterable$ = SubListIterable$;
1826 exports.ListIterator = ListIterator;
1827 exports.ListIterator$ = ListIterator$;
1828 exports.MappedIterable = MappedIterable;
1829 exports.MappedIterable$ = MappedIterable$;
1830 exports.EfficientLengthMappedIterable = EfficientLengthMappedIterable;
1831 exports.EfficientLengthMappedIterable$ = EfficientLengthMappedIterable$;
1832 exports.MappedIterator = MappedIterator;
1833 exports.MappedIterator$ = MappedIterator$;
1834 exports.MappedListIterable = MappedListIterable;
1835 exports.MappedListIterable$ = MappedListIterable$;
1836 exports.WhereIterable = WhereIterable;
1837 exports.WhereIterable$ = WhereIterable$;
1838 exports.WhereIterator = WhereIterator;
1839 exports.WhereIterator$ = WhereIterator$;
1840 exports.ExpandIterable = ExpandIterable;
1841 exports.ExpandIterable$ = ExpandIterable$;
1842 exports.ExpandIterator = ExpandIterator;
1843 exports.ExpandIterator$ = ExpandIterator$;
1844 exports.TakeIterable = TakeIterable;
1845 exports.TakeIterable$ = TakeIterable$;
1846 exports.EfficientLengthTakeIterable = EfficientLengthTakeIterable;
1847 exports.EfficientLengthTakeIterable$ = EfficientLengthTakeIterable$;
1848 exports.TakeIterator = TakeIterator;
1849 exports.TakeIterator$ = TakeIterator$;
1850 exports.TakeWhileIterable = TakeWhileIterable;
1851 exports.TakeWhileIterable$ = TakeWhileIterable$;
1852 exports.TakeWhileIterator = TakeWhileIterator;
1853 exports.TakeWhileIterator$ = TakeWhileIterator$;
1854 exports.SkipIterable = SkipIterable;
1855 exports.SkipIterable$ = SkipIterable$;
1856 exports.EfficientLengthSkipIterable = EfficientLengthSkipIterable;
1857 exports.EfficientLengthSkipIterable$ = EfficientLengthSkipIterable$;
1858 exports.SkipIterator = SkipIterator;
1859 exports.SkipIterator$ = SkipIterator$;
1860 exports.SkipWhileIterable = SkipWhileIterable;
1861 exports.SkipWhileIterable$ = SkipWhileIterable$;
1862 exports.SkipWhileIterator = SkipWhileIterator;
1863 exports.SkipWhileIterator$ = SkipWhileIterator$;
1864 exports.EmptyIterable = EmptyIterable;
1865 exports.EmptyIterable$ = EmptyIterable$;
1866 exports.EmptyIterator = EmptyIterator;
1867 exports.EmptyIterator$ = EmptyIterator$;
1868 exports.BidirectionalIterator = BidirectionalIterator;
1869 exports.BidirectionalIterator$ = BidirectionalIterator$;
1870 exports.IterableMixinWorkaround = IterableMixinWorkaround;
1871 exports.IterableMixinWorkaround$ = IterableMixinWorkaround$;
1872 exports.IterableElementError = IterableElementError;
1873 exports.FixedLengthListMixin = FixedLengthListMixin;
1874 exports.FixedLengthListMixin$ = FixedLengthListMixin$;
1875 exports.UnmodifiableListMixin = UnmodifiableListMixin;
1876 exports.UnmodifiableListMixin$ = UnmodifiableListMixin$;
1877 exports.FixedLengthListBase = FixedLengthListBase;
1878 exports.FixedLengthListBase$ = FixedLengthListBase$;
1879 exports.UnmodifiableListBase = UnmodifiableListBase;
1880 exports.UnmodifiableListBase$ = UnmodifiableListBase$;
1881 exports.ListMapView = ListMapView;
1882 exports.ListMapView$ = ListMapView$;
1883 exports.ReversedListIterable = ReversedListIterable;
1884 exports.ReversedListIterable$ = ReversedListIterable$;
1885 exports.UnmodifiableListError = UnmodifiableListError;
1886 exports.NonGrowableListError = NonGrowableListError;
1887 exports.makeListFixedLength = makeListFixedLength;
1888 exports.Lists = Lists;
1889 exports.printToConsole = printToConsole;
1890 exports.Sort = Sort;
1891 exports.Symbol = Symbol;
1892 exports.POWERS_OF_TEN = POWERS_OF_TEN;
1893 })(_internal || (_internal = {}));
OLDNEW
« lib/src/utils.dart ('K') | « test/codegen/expect/dart/_interceptors.js ('k') | test/codegen/expect/dart/_isolate_helper.js » ('j') | test/generated_sdk/lib/core/function.dart » ('J')

Powered by Google App Engine
This is Rietveld 408576698