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

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: lib/runtime/dart/_internal.js

Issue 1317933005: Some preliminary support for quasi-generics (Closed) Base URL: https://github.com/dart-lang/dev_compiler.git@master
Patch Set: Address comments Created 5 years, 3 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
« no previous file with comments | « lib/runtime/dart/_interceptors.js ('k') | lib/runtime/dart/_isolate_helper.js » ('j') | lib/src/checker/resolver.dart » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 dart_library.library('dart/_internal', null, /* Imports */[
2 "dart_runtime/dart",
3 'dart/core',
4 'dart/collection'
5 ], /* Lazy imports */[
6 'dart/math',
7 'dart/_interceptors',
8 'dart/_js_primitives'
9 ], function(exports, dart, core, collection, math, _interceptors, _js_primitives ) {
10 'use strict';
11 let dartx = dart.dartx;
12 class EfficientLength extends core.Object {}
13 let ListIterable$ = dart.generic(function(E) {
14 class ListIterable extends collection.IterableBase$(E) {
15 ListIterable() {
16 super.IterableBase();
17 }
18 get iterator() {
19 return new (ListIterator$(E))(this);
20 }
21 forEach(action) {
22 dart.as(action, dart.functionType(dart.void, [E]));
23 let length = this.length;
24 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull (i) + 1) {
25 action(this.elementAt(i));
26 if (length != this.length) {
27 dart.throw(new core.ConcurrentModificationError(this));
28 }
29 }
30 }
31 get isEmpty() {
32 return this.length == 0;
33 }
34 get first() {
35 if (this.length == 0)
36 dart.throw(IterableElementError.noElement());
37 return this.elementAt(0);
38 }
39 get last() {
40 if (this.length == 0)
41 dart.throw(IterableElementError.noElement());
42 return this.elementAt(dart.notNull(this.length) - 1);
43 }
44 get single() {
45 if (this.length == 0)
46 dart.throw(IterableElementError.noElement());
47 if (dart.notNull(this.length) > 1)
48 dart.throw(IterableElementError.tooMany());
49 return this.elementAt(0);
50 }
51 contains(element) {
52 let length = this.length;
53 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull (i) + 1) {
54 if (dart.equals(this.elementAt(i), element))
55 return true;
56 if (length != this.length) {
57 dart.throw(new core.ConcurrentModificationError(this));
58 }
59 }
60 return false;
61 }
62 every(test) {
63 dart.as(test, dart.functionType(core.bool, [E]));
64 let length = this.length;
65 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull (i) + 1) {
66 if (!dart.notNull(test(this.elementAt(i))))
67 return false;
68 if (length != this.length) {
69 dart.throw(new core.ConcurrentModificationError(this));
70 }
71 }
72 return true;
73 }
74 any(test) {
75 dart.as(test, dart.functionType(core.bool, [E]));
76 let length = this.length;
77 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull (i) + 1) {
78 if (dart.notNull(test(this.elementAt(i))))
79 return true;
80 if (length != this.length) {
81 dart.throw(new core.ConcurrentModificationError(this));
82 }
83 }
84 return false;
85 }
86 firstWhere(test, opts) {
87 dart.as(test, dart.functionType(core.bool, [E]));
88 let orElse = opts && 'orElse' in opts ? opts.orElse : null;
89 dart.as(orElse, dart.functionType(E, []));
90 let length = this.length;
91 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull (i) + 1) {
92 let element = this.elementAt(i);
93 if (dart.notNull(test(element)))
94 return element;
95 if (length != this.length) {
96 dart.throw(new core.ConcurrentModificationError(this));
97 }
98 }
99 if (orElse != null)
100 return orElse();
101 dart.throw(IterableElementError.noElement());
102 }
103 lastWhere(test, opts) {
104 dart.as(test, dart.functionType(core.bool, [E]));
105 let orElse = opts && 'orElse' in opts ? opts.orElse : null;
106 dart.as(orElse, dart.functionType(E, []));
107 let length = this.length;
108 for (let i = dart.notNull(length) - 1; dart.notNull(i) >= 0; i = dart.no tNull(i) - 1) {
109 let element = this.elementAt(i);
110 if (dart.notNull(test(element)))
111 return element;
112 if (length != this.length) {
113 dart.throw(new core.ConcurrentModificationError(this));
114 }
115 }
116 if (orElse != null)
117 return orElse();
118 dart.throw(IterableElementError.noElement());
119 }
120 singleWhere(test) {
121 dart.as(test, dart.functionType(core.bool, [E]));
122 let length = this.length;
123 let match = null;
124 let matchFound = false;
125 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull (i) + 1) {
126 let element = this.elementAt(i);
127 if (dart.notNull(test(element))) {
128 if (dart.notNull(matchFound)) {
129 dart.throw(IterableElementError.tooMany());
130 }
131 matchFound = true;
132 match = element;
133 }
134 if (length != this.length) {
135 dart.throw(new core.ConcurrentModificationError(this));
136 }
137 }
138 if (dart.notNull(matchFound))
139 return match;
140 dart.throw(IterableElementError.noElement());
141 }
142 join(separator) {
143 if (separator === void 0)
144 separator = "";
145 let length = this.length;
146 if (!dart.notNull(separator[dartx.isEmpty])) {
147 if (length == 0)
148 return "";
149 let first = `${this.elementAt(0)}`;
150 if (length != this.length) {
151 dart.throw(new core.ConcurrentModificationError(this));
152 }
153 let buffer = new core.StringBuffer(first);
154 for (let i = 1; dart.notNull(i) < dart.notNull(length); i = dart.notNu ll(i) + 1) {
155 buffer.write(separator);
156 buffer.write(this.elementAt(i));
157 if (length != this.length) {
158 dart.throw(new core.ConcurrentModificationError(this));
159 }
160 }
161 return dart.toString(buffer);
162 } else {
163 let buffer = new core.StringBuffer();
164 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNu ll(i) + 1) {
165 buffer.write(this.elementAt(i));
166 if (length != this.length) {
167 dart.throw(new core.ConcurrentModificationError(this));
168 }
169 }
170 return dart.toString(buffer);
171 }
172 }
173 where(test) {
174 dart.as(test, dart.functionType(core.bool, [E]));
175 return super.where(test);
176 }
177 map(f) {
178 dart.as(f, dart.functionType(dart.dynamic, [E]));
179 return new MappedListIterable(this, f);
180 }
181 reduce(combine) {
182 dart.as(combine, dart.functionType(E, [dart.dynamic, E]));
183 let length = this.length;
184 if (length == 0)
185 dart.throw(IterableElementError.noElement());
186 let value = this.elementAt(0);
187 for (let i = 1; dart.notNull(i) < dart.notNull(length); i = dart.notNull (i) + 1) {
188 value = dart.dcall(combine, value, this.elementAt(i));
189 if (length != this.length) {
190 dart.throw(new core.ConcurrentModificationError(this));
191 }
192 }
193 return value;
194 }
195 fold(initialValue, combine) {
196 dart.as(combine, dart.functionType(dart.dynamic, [dart.dynamic, E]));
197 let value = initialValue;
198 let length = this.length;
199 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull (i) + 1) {
200 value = dart.dcall(combine, value, this.elementAt(i));
201 if (length != this.length) {
202 dart.throw(new core.ConcurrentModificationError(this));
203 }
204 }
205 return value;
206 }
207 skip(count) {
208 return new (SubListIterable$(E))(this, count, null);
209 }
210 skipWhile(test) {
211 dart.as(test, dart.functionType(core.bool, [E]));
212 return super.skipWhile(test);
213 }
214 take(count) {
215 return new (SubListIterable$(E))(this, 0, count);
216 }
217 takeWhile(test) {
218 dart.as(test, dart.functionType(core.bool, [E]));
219 return super.takeWhile(test);
220 }
221 toList(opts) {
222 let growable = opts && 'growable' in opts ? opts.growable : true;
223 let result = null;
224 if (dart.notNull(growable)) {
225 result = core.List$(E).new();
226 result[dartx.length] = this.length;
227 } else {
228 result = core.List$(E).new(this.length);
229 }
230 for (let i = 0; dart.notNull(i) < dart.notNull(this.length); i = dart.no tNull(i) + 1) {
231 result[dartx.set](i, this.elementAt(i));
232 }
233 return result;
234 }
235 toSet() {
236 let result = core.Set$(E).new();
237 for (let i = 0; dart.notNull(i) < dart.notNull(this.length); i = dart.no tNull(i) + 1) {
238 result.add(this.elementAt(i));
239 }
240 return result;
241 }
242 }
243 ListIterable[dart.implements] = () => [EfficientLength];
244 dart.setSignature(ListIterable, {
245 constructors: () => ({ListIterable: [ListIterable$(E), []]}),
246 methods: () => ({
247 forEach: [dart.void, [dart.functionType(dart.void, [E])]],
248 every: [core.bool, [dart.functionType(core.bool, [E])]],
249 any: [core.bool, [dart.functionType(core.bool, [E])]],
250 firstWhere: [E, [dart.functionType(core.bool, [E])], {orElse: dart.funct ionType(E, [])}],
251 lastWhere: [E, [dart.functionType(core.bool, [E])], {orElse: dart.functi onType(E, [])}],
252 singleWhere: [E, [dart.functionType(core.bool, [E])]],
253 where: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
254 map: [core.Iterable, [dart.functionType(dart.dynamic, [E])]],
255 reduce: [E, [dart.functionType(E, [dart.dynamic, E])]],
256 fold: [dart.dynamic, [dart.dynamic, dart.functionType(dart.dynamic, [dar t.dynamic, E])]],
257 skip: [core.Iterable$(E), [core.int]],
258 skipWhile: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
259 take: [core.Iterable$(E), [core.int]],
260 takeWhile: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
261 toList: [core.List$(E), [], {growable: core.bool}],
262 toSet: [core.Set$(E), []]
263 })
264 });
265 dart.defineExtensionMembers(ListIterable, [
266 'forEach',
267 'contains',
268 'every',
269 'any',
270 'firstWhere',
271 'lastWhere',
272 'singleWhere',
273 'join',
274 'where',
275 'map',
276 'reduce',
277 'fold',
278 'skip',
279 'skipWhile',
280 'take',
281 'takeWhile',
282 'toList',
283 'toSet',
284 'iterator',
285 'isEmpty',
286 'first',
287 'last',
288 'single'
289 ]);
290 return ListIterable;
291 });
292 let ListIterable = ListIterable$();
293 let _iterable = dart.JsSymbol('_iterable');
294 let _start = dart.JsSymbol('_start');
295 let _endOrLength = dart.JsSymbol('_endOrLength');
296 let _endIndex = dart.JsSymbol('_endIndex');
297 let _startIndex = dart.JsSymbol('_startIndex');
298 let SubListIterable$ = dart.generic(function(E) {
299 class SubListIterable extends ListIterable$(E) {
300 SubListIterable(iterable, start, endOrLength) {
301 this[_iterable] = iterable;
302 this[_start] = start;
303 this[_endOrLength] = endOrLength;
304 super.ListIterable();
305 core.RangeError.checkNotNegative(this[_start], "start");
306 if (this[_endOrLength] != null) {
307 core.RangeError.checkNotNegative(this[_endOrLength], "end");
308 if (dart.notNull(this[_start]) > dart.notNull(this[_endOrLength])) {
309 dart.throw(new core.RangeError.range(this[_start], 0, this[_endOrLen gth], "start"));
310 }
311 }
312 }
313 get [_endIndex]() {
314 let length = this[_iterable][dartx.length];
315 if (this[_endOrLength] == null || dart.notNull(this[_endOrLength]) > dar t.notNull(length))
316 return length;
317 return this[_endOrLength];
318 }
319 get [_startIndex]() {
320 let length = this[_iterable][dartx.length];
321 if (dart.notNull(this[_start]) > dart.notNull(length))
322 return length;
323 return this[_start];
324 }
325 get length() {
326 let length = this[_iterable][dartx.length];
327 if (dart.notNull(this[_start]) >= dart.notNull(length))
328 return 0;
329 if (this[_endOrLength] == null || dart.notNull(this[_endOrLength]) >= da rt.notNull(length)) {
330 return dart.notNull(length) - dart.notNull(this[_start]);
331 }
332 return dart.notNull(this[_endOrLength]) - dart.notNull(this[_start]);
333 }
334 elementAt(index) {
335 let realIndex = dart.notNull(this[_startIndex]) + dart.notNull(index);
336 if (dart.notNull(index) < 0 || dart.notNull(realIndex) >= dart.notNull(t his[_endIndex])) {
337 dart.throw(core.RangeError.index(index, this, "index"));
338 }
339 return this[_iterable][dartx.elementAt](realIndex);
340 }
341 skip(count) {
342 core.RangeError.checkNotNegative(count, "count");
343 let newStart = dart.notNull(this[_start]) + dart.notNull(count);
344 if (this[_endOrLength] != null && dart.notNull(newStart) >= dart.notNull (this[_endOrLength])) {
345 return new (EmptyIterable$(E))();
346 }
347 return new (SubListIterable$(E))(this[_iterable], newStart, this[_endOrL ength]);
348 }
349 take(count) {
350 core.RangeError.checkNotNegative(count, "count");
351 if (this[_endOrLength] == null) {
352 return new (SubListIterable$(E))(this[_iterable], this[_start], dart.n otNull(this[_start]) + dart.notNull(count));
353 } else {
354 let newEnd = dart.notNull(this[_start]) + dart.notNull(count);
355 if (dart.notNull(this[_endOrLength]) < dart.notNull(newEnd))
356 return this;
357 return new (SubListIterable$(E))(this[_iterable], this[_start], newEnd );
358 }
359 }
360 toList(opts) {
361 let growable = opts && 'growable' in opts ? opts.growable : true;
362 let start = this[_start];
363 let end = this[_iterable][dartx.length];
364 if (this[_endOrLength] != null && dart.notNull(this[_endOrLength]) < dar t.notNull(end))
365 end = this[_endOrLength];
366 let length = dart.notNull(end) - dart.notNull(start);
367 if (dart.notNull(length) < 0)
368 length = 0;
369 let result = dart.notNull(growable) ? (() => {
370 let _ = core.List$(E).new();
371 _[dartx.length] = length;
372 return _;
373 })() : core.List$(E).new(length);
374 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull (i) + 1) {
375 result[dartx.set](i, this[_iterable][dartx.elementAt](dart.notNull(sta rt) + dart.notNull(i)));
376 if (dart.notNull(this[_iterable][dartx.length]) < dart.notNull(end))
377 dart.throw(new core.ConcurrentModificationError(this));
378 }
379 return dart.as(result, core.List$(E));
380 }
381 }
382 dart.setSignature(SubListIterable, {
383 constructors: () => ({SubListIterable: [SubListIterable$(E), [core.Iterabl e$(E), core.int, core.int]]}),
384 methods: () => ({
385 elementAt: [E, [core.int]],
386 skip: [core.Iterable$(E), [core.int]],
387 take: [core.Iterable$(E), [core.int]],
388 toList: [core.List$(E), [], {growable: core.bool}]
389 })
390 });
391 dart.defineExtensionMembers(SubListIterable, [
392 'elementAt',
393 'skip',
394 'take',
395 'toList',
396 'length'
397 ]);
398 return SubListIterable;
399 });
400 let SubListIterable = SubListIterable$();
401 let _length = dart.JsSymbol('_length');
402 let _index = dart.JsSymbol('_index');
403 let _current = dart.JsSymbol('_current');
404 let ListIterator$ = dart.generic(function(E) {
405 class ListIterator extends core.Object {
406 ListIterator(iterable) {
407 this[_iterable] = iterable;
408 this[_length] = iterable[dartx.length];
409 this[_index] = 0;
410 this[_current] = null;
411 }
412 get current() {
413 return this[_current];
414 }
415 moveNext() {
416 let length = this[_iterable][dartx.length];
417 if (this[_length] != length) {
418 dart.throw(new core.ConcurrentModificationError(this[_iterable]));
419 }
420 if (dart.notNull(this[_index]) >= dart.notNull(length)) {
421 this[_current] = null;
422 return false;
423 }
424 this[_current] = this[_iterable][dartx.elementAt](this[_index]);
425 this[_index] = dart.notNull(this[_index]) + 1;
426 return true;
427 }
428 }
429 ListIterator[dart.implements] = () => [core.Iterator$(E)];
430 dart.setSignature(ListIterator, {
431 constructors: () => ({ListIterator: [ListIterator$(E), [core.Iterable$(E)] ]}),
432 methods: () => ({moveNext: [core.bool, []]})
433 });
434 return ListIterator;
435 });
436 let ListIterator = ListIterator$();
437 let _Transformation$ = dart.generic(function(S, T) {
438 let _Transformation = dart.typedef('_Transformation', () => dart.functionTyp e(T, [S]));
439 return _Transformation;
440 });
441 let _Transformation = _Transformation$();
442 let _f = dart.JsSymbol('_f');
443 let MappedIterable$ = dart.generic(function(S, T) {
444 class MappedIterable extends collection.IterableBase$(T) {
445 static new(iterable, func) {
446 if (dart.is(iterable, EfficientLength)) {
447 return new (EfficientLengthMappedIterable$(S, T))(iterable, func);
448 }
449 return new (MappedIterable$(S, T))._(dart.as(iterable, core.Iterable$(S) ), func);
450 }
451 _(iterable, f) {
452 this[_iterable] = iterable;
453 this[_f] = f;
454 super.IterableBase();
455 }
456 get iterator() {
457 return new (MappedIterator$(S, T))(this[_iterable][dartx.iterator], this [_f]);
458 }
459 get length() {
460 return this[_iterable][dartx.length];
461 }
462 get isEmpty() {
463 return this[_iterable][dartx.isEmpty];
464 }
465 get first() {
466 return this[_f](this[_iterable][dartx.first]);
467 }
468 get last() {
469 return this[_f](this[_iterable][dartx.last]);
470 }
471 get single() {
472 return this[_f](this[_iterable][dartx.single]);
473 }
474 elementAt(index) {
475 return this[_f](this[_iterable][dartx.elementAt](index));
476 }
477 }
478 dart.defineNamedConstructor(MappedIterable, '_');
479 dart.setSignature(MappedIterable, {
480 constructors: () => ({
481 new: [MappedIterable$(S, T), [core.Iterable, dart.functionType(T, [S])]] ,
482 _: [MappedIterable$(S, T), [core.Iterable$(S), dart.functionType(T, [S]) ]]
483 }),
484 methods: () => ({elementAt: [T, [core.int]]})
485 });
486 dart.defineExtensionMembers(MappedIterable, [
487 'elementAt',
488 'iterator',
489 'length',
490 'isEmpty',
491 'first',
492 'last',
493 'single'
494 ]);
495 return MappedIterable;
496 });
497 let MappedIterable = MappedIterable$();
498 let EfficientLengthMappedIterable$ = dart.generic(function(S, T) {
499 class EfficientLengthMappedIterable extends MappedIterable$(S, T) {
500 EfficientLengthMappedIterable(iterable, func) {
501 super._(dart.as(iterable, core.Iterable$(S)), func);
502 }
503 }
504 EfficientLengthMappedIterable[dart.implements] = () => [EfficientLength];
505 dart.setSignature(EfficientLengthMappedIterable, {
506 constructors: () => ({EfficientLengthMappedIterable: [EfficientLengthMappe dIterable$(S, T), [core.Iterable, dart.functionType(T, [S])]]})
507 });
508 return EfficientLengthMappedIterable;
509 });
510 let EfficientLengthMappedIterable = EfficientLengthMappedIterable$();
511 let _iterator = dart.JsSymbol('_iterator');
512 let MappedIterator$ = dart.generic(function(S, T) {
513 class MappedIterator extends core.Iterator$(T) {
514 MappedIterator(iterator, f) {
515 this[_iterator] = iterator;
516 this[_f] = f;
517 this[_current] = null;
518 }
519 moveNext() {
520 if (dart.notNull(this[_iterator].moveNext())) {
521 this[_current] = this[_f](this[_iterator].current);
522 return true;
523 }
524 this[_current] = null;
525 return false;
526 }
527 get current() {
528 return this[_current];
529 }
530 }
531 dart.setSignature(MappedIterator, {
532 constructors: () => ({MappedIterator: [MappedIterator$(S, T), [core.Iterat or$(S), dart.functionType(T, [S])]]}),
533 methods: () => ({moveNext: [core.bool, []]})
534 });
535 return MappedIterator;
536 });
537 let MappedIterator = MappedIterator$();
538 let _source = dart.JsSymbol('_source');
539 let MappedListIterable$ = dart.generic(function(S, T) {
540 class MappedListIterable extends ListIterable$(T) {
541 MappedListIterable(source, f) {
542 this[_source] = source;
543 this[_f] = f;
544 super.ListIterable();
545 }
546 get length() {
547 return this[_source][dartx.length];
548 }
549 elementAt(index) {
550 return this[_f](this[_source][dartx.elementAt](index));
551 }
552 }
553 MappedListIterable[dart.implements] = () => [EfficientLength];
554 dart.setSignature(MappedListIterable, {
555 constructors: () => ({MappedListIterable: [MappedListIterable$(S, T), [cor e.Iterable$(S), dart.functionType(T, [S])]]}),
556 methods: () => ({elementAt: [T, [core.int]]})
557 });
558 dart.defineExtensionMembers(MappedListIterable, ['elementAt', 'length']);
559 return MappedListIterable;
560 });
561 let MappedListIterable = MappedListIterable$();
562 let _ElementPredicate$ = dart.generic(function(E) {
563 let _ElementPredicate = dart.typedef('_ElementPredicate', () => dart.functio nType(core.bool, [E]));
564 return _ElementPredicate;
565 });
566 let _ElementPredicate = _ElementPredicate$();
567 let WhereIterable$ = dart.generic(function(E) {
568 class WhereIterable extends collection.IterableBase$(E) {
569 WhereIterable(iterable, f) {
570 this[_iterable] = iterable;
571 this[_f] = f;
572 super.IterableBase();
573 }
574 get iterator() {
575 return new (WhereIterator$(E))(this[_iterable][dartx.iterator], this[_f] );
576 }
577 }
578 dart.setSignature(WhereIterable, {
579 constructors: () => ({WhereIterable: [WhereIterable$(E), [core.Iterable$(E ), dart.functionType(core.bool, [E])]]})
580 });
581 dart.defineExtensionMembers(WhereIterable, ['iterator']);
582 return WhereIterable;
583 });
584 let WhereIterable = WhereIterable$();
585 let WhereIterator$ = dart.generic(function(E) {
586 class WhereIterator extends core.Iterator$(E) {
587 WhereIterator(iterator, f) {
588 this[_iterator] = iterator;
589 this[_f] = f;
590 }
591 moveNext() {
592 while (dart.notNull(this[_iterator].moveNext())) {
593 if (dart.notNull(this[_f](this[_iterator].current))) {
594 return true;
595 }
596 }
597 return false;
598 }
599 get current() {
600 return this[_iterator].current;
601 }
602 }
603 dart.setSignature(WhereIterator, {
604 constructors: () => ({WhereIterator: [WhereIterator$(E), [core.Iterator$(E ), dart.functionType(core.bool, [E])]]}),
605 methods: () => ({moveNext: [core.bool, []]})
606 });
607 return WhereIterator;
608 });
609 let WhereIterator = WhereIterator$();
610 let _ExpandFunction$ = dart.generic(function(S, T) {
611 let _ExpandFunction = dart.typedef('_ExpandFunction', () => dart.functionTyp e(core.Iterable$(T), [S]));
612 return _ExpandFunction;
613 });
614 let _ExpandFunction = _ExpandFunction$();
615 let ExpandIterable$ = dart.generic(function(S, T) {
616 class ExpandIterable extends collection.IterableBase$(T) {
617 ExpandIterable(iterable, f) {
618 this[_iterable] = iterable;
619 this[_f] = f;
620 super.IterableBase();
621 }
622 get iterator() {
623 return new (ExpandIterator$(S, T))(this[_iterable][dartx.iterator], dart .as(this[_f], __CastType0));
624 }
625 }
626 dart.setSignature(ExpandIterable, {
627 constructors: () => ({ExpandIterable: [ExpandIterable$(S, T), [core.Iterab le$(S), dart.functionType(core.Iterable$(T), [S])]]})
628 });
629 dart.defineExtensionMembers(ExpandIterable, ['iterator']);
630 return ExpandIterable;
631 });
632 let ExpandIterable = ExpandIterable$();
633 let _currentExpansion = dart.JsSymbol('_currentExpansion');
634 let _nextExpansion = dart.JsSymbol('_nextExpansion');
635 let ExpandIterator$ = dart.generic(function(S, T) {
636 class ExpandIterator extends core.Object {
637 ExpandIterator(iterator, f) {
638 this[_iterator] = iterator;
639 this[_f] = f;
640 this[_currentExpansion] = dart.const(new (EmptyIterator$(T))());
641 this[_current] = null;
642 }
643 [_nextExpansion]() {}
644 get current() {
645 return this[_current];
646 }
647 moveNext() {
648 if (this[_currentExpansion] == null)
649 return false;
650 while (!dart.notNull(this[_currentExpansion].moveNext())) {
651 this[_current] = null;
652 if (dart.notNull(this[_iterator].moveNext())) {
653 this[_currentExpansion] = null;
654 this[_currentExpansion] = dart.as(dart.dcall(this[_f], this[_iterato r].current)[dartx.iterator], core.Iterator$(T));
655 } else {
656 return false;
657 }
658 }
659 this[_current] = this[_currentExpansion].current;
660 return true;
661 }
662 }
663 ExpandIterator[dart.implements] = () => [core.Iterator$(T)];
664 dart.setSignature(ExpandIterator, {
665 constructors: () => ({ExpandIterator: [ExpandIterator$(S, T), [core.Iterat or$(S), dart.functionType(core.Iterable$(T), [S])]]}),
666 methods: () => ({
667 [_nextExpansion]: [dart.void, []],
668 moveNext: [core.bool, []]
669 })
670 });
671 return ExpandIterator;
672 });
673 let ExpandIterator = ExpandIterator$();
674 let _takeCount = dart.JsSymbol('_takeCount');
675 let TakeIterable$ = dart.generic(function(E) {
676 class TakeIterable extends collection.IterableBase$(E) {
677 static new(iterable, takeCount) {
678 if (!(typeof takeCount == 'number') || dart.notNull(takeCount) < 0) {
679 dart.throw(new core.ArgumentError(takeCount));
680 }
681 if (dart.is(iterable, EfficientLength)) {
682 return new (EfficientLengthTakeIterable$(E))(iterable, takeCount);
683 }
684 return new (TakeIterable$(E))._(iterable, takeCount);
685 }
686 _(iterable, takeCount) {
687 this[_iterable] = iterable;
688 this[_takeCount] = takeCount;
689 super.IterableBase();
690 }
691 get iterator() {
692 return new (TakeIterator$(E))(this[_iterable][dartx.iterator], this[_tak eCount]);
693 }
694 }
695 dart.defineNamedConstructor(TakeIterable, '_');
696 dart.setSignature(TakeIterable, {
697 constructors: () => ({
698 new: [TakeIterable$(E), [core.Iterable$(E), core.int]],
699 _: [TakeIterable$(E), [core.Iterable$(E), core.int]]
700 })
701 });
702 dart.defineExtensionMembers(TakeIterable, ['iterator']);
703 return TakeIterable;
704 });
705 let TakeIterable = TakeIterable$();
706 let EfficientLengthTakeIterable$ = dart.generic(function(E) {
707 class EfficientLengthTakeIterable extends TakeIterable$(E) {
708 EfficientLengthTakeIterable(iterable, takeCount) {
709 super._(iterable, takeCount);
710 }
711 get length() {
712 let iterableLength = this[_iterable][dartx.length];
713 if (dart.notNull(iterableLength) > dart.notNull(this[_takeCount]))
714 return this[_takeCount];
715 return iterableLength;
716 }
717 }
718 EfficientLengthTakeIterable[dart.implements] = () => [EfficientLength];
719 dart.setSignature(EfficientLengthTakeIterable, {
720 constructors: () => ({EfficientLengthTakeIterable: [EfficientLengthTakeIte rable$(E), [core.Iterable$(E), core.int]]})
721 });
722 dart.defineExtensionMembers(EfficientLengthTakeIterable, ['length']);
723 return EfficientLengthTakeIterable;
724 });
725 let EfficientLengthTakeIterable = EfficientLengthTakeIterable$();
726 let _remaining = dart.JsSymbol('_remaining');
727 let TakeIterator$ = dart.generic(function(E) {
728 class TakeIterator extends core.Iterator$(E) {
729 TakeIterator(iterator, remaining) {
730 this[_iterator] = iterator;
731 this[_remaining] = remaining;
732 dart.assert(typeof this[_remaining] == 'number' && dart.notNull(this[_re maining]) >= 0);
733 }
734 moveNext() {
735 this[_remaining] = dart.notNull(this[_remaining]) - 1;
736 if (dart.notNull(this[_remaining]) >= 0) {
737 return this[_iterator].moveNext();
738 }
739 this[_remaining] = -1;
740 return false;
741 }
742 get current() {
743 if (dart.notNull(this[_remaining]) < 0)
744 return null;
745 return this[_iterator].current;
746 }
747 }
748 dart.setSignature(TakeIterator, {
749 constructors: () => ({TakeIterator: [TakeIterator$(E), [core.Iterator$(E), core.int]]}),
750 methods: () => ({moveNext: [core.bool, []]})
751 });
752 return TakeIterator;
753 });
754 let TakeIterator = TakeIterator$();
755 let TakeWhileIterable$ = dart.generic(function(E) {
756 class TakeWhileIterable extends collection.IterableBase$(E) {
757 TakeWhileIterable(iterable, f) {
758 this[_iterable] = iterable;
759 this[_f] = f;
760 super.IterableBase();
761 }
762 get iterator() {
763 return new (TakeWhileIterator$(E))(this[_iterable][dartx.iterator], this [_f]);
764 }
765 }
766 dart.setSignature(TakeWhileIterable, {
767 constructors: () => ({TakeWhileIterable: [TakeWhileIterable$(E), [core.Ite rable$(E), dart.functionType(core.bool, [E])]]})
768 });
769 dart.defineExtensionMembers(TakeWhileIterable, ['iterator']);
770 return TakeWhileIterable;
771 });
772 let TakeWhileIterable = TakeWhileIterable$();
773 let _isFinished = dart.JsSymbol('_isFinished');
774 let TakeWhileIterator$ = dart.generic(function(E) {
775 class TakeWhileIterator extends core.Iterator$(E) {
776 TakeWhileIterator(iterator, f) {
777 this[_iterator] = iterator;
778 this[_f] = f;
779 this[_isFinished] = false;
780 }
781 moveNext() {
782 if (dart.notNull(this[_isFinished]))
783 return false;
784 if (!dart.notNull(this[_iterator].moveNext()) || !dart.notNull(this[_f]( this[_iterator].current))) {
785 this[_isFinished] = true;
786 return false;
787 }
788 return true;
789 }
790 get current() {
791 if (dart.notNull(this[_isFinished]))
792 return null;
793 return this[_iterator].current;
794 }
795 }
796 dart.setSignature(TakeWhileIterator, {
797 constructors: () => ({TakeWhileIterator: [TakeWhileIterator$(E), [core.Ite rator$(E), dart.functionType(core.bool, [E])]]}),
798 methods: () => ({moveNext: [core.bool, []]})
799 });
800 return TakeWhileIterator;
801 });
802 let TakeWhileIterator = TakeWhileIterator$();
803 let _skipCount = dart.JsSymbol('_skipCount');
804 let SkipIterable$ = dart.generic(function(E) {
805 class SkipIterable extends collection.IterableBase$(E) {
806 static new(iterable, count) {
807 if (dart.is(iterable, EfficientLength)) {
808 return new (EfficientLengthSkipIterable$(E))(iterable, count);
809 }
810 return new (SkipIterable$(E))._(iterable, count);
811 }
812 _(iterable, skipCount) {
813 this[_iterable] = iterable;
814 this[_skipCount] = skipCount;
815 super.IterableBase();
816 if (!(typeof this[_skipCount] == 'number')) {
817 dart.throw(new core.ArgumentError.value(this[_skipCount], "count is no t an integer"));
818 }
819 core.RangeError.checkNotNegative(this[_skipCount], "count");
820 }
821 skip(count) {
822 if (!(typeof this[_skipCount] == 'number')) {
823 dart.throw(new core.ArgumentError.value(this[_skipCount], "count is no t an integer"));
824 }
825 core.RangeError.checkNotNegative(this[_skipCount], "count");
826 return new (SkipIterable$(E))._(this[_iterable], dart.notNull(this[_skip Count]) + dart.notNull(count));
827 }
828 get iterator() {
829 return new (SkipIterator$(E))(this[_iterable][dartx.iterator], this[_ski pCount]);
830 }
831 }
832 dart.defineNamedConstructor(SkipIterable, '_');
833 dart.setSignature(SkipIterable, {
834 constructors: () => ({
835 new: [SkipIterable$(E), [core.Iterable$(E), core.int]],
836 _: [SkipIterable$(E), [core.Iterable$(E), core.int]]
837 }),
838 methods: () => ({skip: [core.Iterable$(E), [core.int]]})
839 });
840 dart.defineExtensionMembers(SkipIterable, ['skip', 'iterator']);
841 return SkipIterable;
842 });
843 let SkipIterable = SkipIterable$();
844 let EfficientLengthSkipIterable$ = dart.generic(function(E) {
845 class EfficientLengthSkipIterable extends SkipIterable$(E) {
846 EfficientLengthSkipIterable(iterable, skipCount) {
847 super._(iterable, skipCount);
848 }
849 get length() {
850 let length = dart.notNull(this[_iterable][dartx.length]) - dart.notNull( this[_skipCount]);
851 if (dart.notNull(length) >= 0)
852 return length;
853 return 0;
854 }
855 }
856 EfficientLengthSkipIterable[dart.implements] = () => [EfficientLength];
857 dart.setSignature(EfficientLengthSkipIterable, {
858 constructors: () => ({EfficientLengthSkipIterable: [EfficientLengthSkipIte rable$(E), [core.Iterable$(E), core.int]]})
859 });
860 dart.defineExtensionMembers(EfficientLengthSkipIterable, ['length']);
861 return EfficientLengthSkipIterable;
862 });
863 let EfficientLengthSkipIterable = EfficientLengthSkipIterable$();
864 let SkipIterator$ = dart.generic(function(E) {
865 class SkipIterator extends core.Iterator$(E) {
866 SkipIterator(iterator, skipCount) {
867 this[_iterator] = iterator;
868 this[_skipCount] = skipCount;
869 dart.assert(typeof this[_skipCount] == 'number' && dart.notNull(this[_sk ipCount]) >= 0);
870 }
871 moveNext() {
872 for (let i = 0; dart.notNull(i) < dart.notNull(this[_skipCount]); i = da rt.notNull(i) + 1)
873 this[_iterator].moveNext();
874 this[_skipCount] = 0;
875 return this[_iterator].moveNext();
876 }
877 get current() {
878 return this[_iterator].current;
879 }
880 }
881 dart.setSignature(SkipIterator, {
882 constructors: () => ({SkipIterator: [SkipIterator$(E), [core.Iterator$(E), core.int]]}),
883 methods: () => ({moveNext: [core.bool, []]})
884 });
885 return SkipIterator;
886 });
887 let SkipIterator = SkipIterator$();
888 let SkipWhileIterable$ = dart.generic(function(E) {
889 class SkipWhileIterable extends collection.IterableBase$(E) {
890 SkipWhileIterable(iterable, f) {
891 this[_iterable] = iterable;
892 this[_f] = f;
893 super.IterableBase();
894 }
895 get iterator() {
896 return new (SkipWhileIterator$(E))(this[_iterable][dartx.iterator], this [_f]);
897 }
898 }
899 dart.setSignature(SkipWhileIterable, {
900 constructors: () => ({SkipWhileIterable: [SkipWhileIterable$(E), [core.Ite rable$(E), dart.functionType(core.bool, [E])]]})
901 });
902 dart.defineExtensionMembers(SkipWhileIterable, ['iterator']);
903 return SkipWhileIterable;
904 });
905 let SkipWhileIterable = SkipWhileIterable$();
906 let _hasSkipped = dart.JsSymbol('_hasSkipped');
907 let SkipWhileIterator$ = dart.generic(function(E) {
908 class SkipWhileIterator extends core.Iterator$(E) {
909 SkipWhileIterator(iterator, f) {
910 this[_iterator] = iterator;
911 this[_f] = f;
912 this[_hasSkipped] = false;
913 }
914 moveNext() {
915 if (!dart.notNull(this[_hasSkipped])) {
916 this[_hasSkipped] = true;
917 while (dart.notNull(this[_iterator].moveNext())) {
918 if (!dart.notNull(this[_f](this[_iterator].current)))
919 return true;
920 }
921 }
922 return this[_iterator].moveNext();
923 }
924 get current() {
925 return this[_iterator].current;
926 }
927 }
928 dart.setSignature(SkipWhileIterator, {
929 constructors: () => ({SkipWhileIterator: [SkipWhileIterator$(E), [core.Ite rator$(E), dart.functionType(core.bool, [E])]]}),
930 methods: () => ({moveNext: [core.bool, []]})
931 });
932 return SkipWhileIterator;
933 });
934 let SkipWhileIterator = SkipWhileIterator$();
935 let EmptyIterable$ = dart.generic(function(E) {
936 class EmptyIterable extends collection.IterableBase$(E) {
937 EmptyIterable() {
938 super.IterableBase();
939 }
940 get iterator() {
941 return dart.const(new (EmptyIterator$(E))());
942 }
943 forEach(action) {
944 dart.as(action, dart.functionType(dart.void, [E]));
945 }
946 get isEmpty() {
947 return true;
948 }
949 get length() {
950 return 0;
951 }
952 get first() {
953 dart.throw(IterableElementError.noElement());
954 }
955 get last() {
956 dart.throw(IterableElementError.noElement());
957 }
958 get single() {
959 dart.throw(IterableElementError.noElement());
960 }
961 elementAt(index) {
962 dart.throw(new core.RangeError.range(index, 0, 0, "index"));
963 }
964 contains(element) {
965 return false;
966 }
967 every(test) {
968 dart.as(test, dart.functionType(core.bool, [E]));
969 return true;
970 }
971 any(test) {
972 dart.as(test, dart.functionType(core.bool, [E]));
973 return false;
974 }
975 firstWhere(test, opts) {
976 dart.as(test, dart.functionType(core.bool, [E]));
977 let orElse = opts && 'orElse' in opts ? opts.orElse : null;
978 dart.as(orElse, dart.functionType(E, []));
979 if (orElse != null)
980 return orElse();
981 dart.throw(IterableElementError.noElement());
982 }
983 lastWhere(test, opts) {
984 dart.as(test, dart.functionType(core.bool, [E]));
985 let orElse = opts && 'orElse' in opts ? opts.orElse : null;
986 dart.as(orElse, dart.functionType(E, []));
987 if (orElse != null)
988 return orElse();
989 dart.throw(IterableElementError.noElement());
990 }
991 singleWhere(test, opts) {
992 dart.as(test, dart.functionType(core.bool, [E]));
993 let orElse = opts && 'orElse' in opts ? opts.orElse : null;
994 dart.as(orElse, dart.functionType(E, []));
995 if (orElse != null)
996 return orElse();
997 dart.throw(IterableElementError.noElement());
998 }
999 join(separator) {
1000 if (separator === void 0)
1001 separator = "";
1002 return "";
1003 }
1004 where(test) {
1005 dart.as(test, dart.functionType(core.bool, [E]));
1006 return this;
1007 }
1008 map(f) {
1009 dart.as(f, dart.functionType(dart.dynamic, [E]));
1010 return dart.const(new (EmptyIterable$())());
1011 }
1012 reduce(combine) {
1013 dart.as(combine, dart.functionType(E, [E, E]));
1014 dart.throw(IterableElementError.noElement());
1015 }
1016 fold(initialValue, combine) {
1017 dart.as(combine, dart.functionType(dart.dynamic, [dart.dynamic, E]));
1018 return initialValue;
1019 }
1020 skip(count) {
1021 core.RangeError.checkNotNegative(count, "count");
1022 return this;
1023 }
1024 skipWhile(test) {
1025 dart.as(test, dart.functionType(core.bool, [E]));
1026 return this;
1027 }
1028 take(count) {
1029 core.RangeError.checkNotNegative(count, "count");
1030 return this;
1031 }
1032 takeWhile(test) {
1033 dart.as(test, dart.functionType(core.bool, [E]));
1034 return this;
1035 }
1036 toList(opts) {
1037 let growable = opts && 'growable' in opts ? opts.growable : true;
1038 return dart.notNull(growable) ? dart.list([], E) : core.List$(E).new(0);
1039 }
1040 toSet() {
1041 return core.Set$(E).new();
1042 }
1043 }
1044 EmptyIterable[dart.implements] = () => [EfficientLength];
1045 dart.setSignature(EmptyIterable, {
1046 constructors: () => ({EmptyIterable: [EmptyIterable$(E), []]}),
1047 methods: () => ({
1048 forEach: [dart.void, [dart.functionType(dart.void, [E])]],
1049 elementAt: [E, [core.int]],
1050 every: [core.bool, [dart.functionType(core.bool, [E])]],
1051 any: [core.bool, [dart.functionType(core.bool, [E])]],
1052 firstWhere: [E, [dart.functionType(core.bool, [E])], {orElse: dart.funct ionType(E, [])}],
1053 lastWhere: [E, [dart.functionType(core.bool, [E])], {orElse: dart.functi onType(E, [])}],
1054 singleWhere: [E, [dart.functionType(core.bool, [E])], {orElse: dart.func tionType(E, [])}],
1055 where: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
1056 map: [core.Iterable, [dart.functionType(dart.dynamic, [E])]],
1057 reduce: [E, [dart.functionType(E, [E, E])]],
1058 fold: [dart.dynamic, [dart.dynamic, dart.functionType(dart.dynamic, [dar t.dynamic, E])]],
1059 skip: [core.Iterable$(E), [core.int]],
1060 skipWhile: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
1061 take: [core.Iterable$(E), [core.int]],
1062 takeWhile: [core.Iterable$(E), [dart.functionType(core.bool, [E])]],
1063 toList: [core.List$(E), [], {growable: core.bool}],
1064 toSet: [core.Set$(E), []]
1065 })
1066 });
1067 dart.defineExtensionMembers(EmptyIterable, [
1068 'forEach',
1069 'elementAt',
1070 'contains',
1071 'every',
1072 'any',
1073 'firstWhere',
1074 'lastWhere',
1075 'singleWhere',
1076 'join',
1077 'where',
1078 'map',
1079 'reduce',
1080 'fold',
1081 'skip',
1082 'skipWhile',
1083 'take',
1084 'takeWhile',
1085 'toList',
1086 'toSet',
1087 'iterator',
1088 'isEmpty',
1089 'length',
1090 'first',
1091 'last',
1092 'single'
1093 ]);
1094 return EmptyIterable;
1095 });
1096 let EmptyIterable = EmptyIterable$();
1097 let EmptyIterator$ = dart.generic(function(E) {
1098 class EmptyIterator extends core.Object {
1099 EmptyIterator() {
1100 }
1101 moveNext() {
1102 return false;
1103 }
1104 get current() {
1105 return null;
1106 }
1107 }
1108 EmptyIterator[dart.implements] = () => [core.Iterator$(E)];
1109 dart.setSignature(EmptyIterator, {
1110 constructors: () => ({EmptyIterator: [EmptyIterator$(E), []]}),
1111 methods: () => ({moveNext: [core.bool, []]})
1112 });
1113 return EmptyIterator;
1114 });
1115 let EmptyIterator = EmptyIterator$();
1116 let BidirectionalIterator$ = dart.generic(function(T) {
1117 class BidirectionalIterator extends core.Object {}
1118 BidirectionalIterator[dart.implements] = () => [core.Iterator$(T)];
1119 return BidirectionalIterator;
1120 });
1121 let BidirectionalIterator = BidirectionalIterator$();
1122 let IterableMixinWorkaround$ = dart.generic(function(T) {
1123 class IterableMixinWorkaround extends core.Object {
1124 static contains(iterable, element) {
1125 for (let e of iterable) {
1126 if (dart.equals(e, element))
1127 return true;
1128 }
1129 return false;
1130 }
1131 static forEach(iterable, f) {
1132 dart.as(f, dart.functionType(dart.void, [dart.dynamic]));
1133 for (let e of iterable) {
1134 dart.dcall(f, e);
1135 }
1136 }
1137 static any(iterable, f) {
1138 dart.as(f, dart.functionType(core.bool, [dart.dynamic]));
1139 for (let e of iterable) {
1140 if (dart.notNull(dart.dcall(f, e)))
1141 return true;
1142 }
1143 return false;
1144 }
1145 static every(iterable, f) {
1146 dart.as(f, dart.functionType(core.bool, [dart.dynamic]));
1147 for (let e of iterable) {
1148 if (!dart.notNull(dart.dcall(f, e)))
1149 return false;
1150 }
1151 return true;
1152 }
1153 static reduce(iterable, combine) {
1154 dart.as(combine, dart.functionType(dart.dynamic, [dart.dynamic, dart.dyn amic]));
1155 let iterator = iterable[dartx.iterator];
1156 if (!dart.notNull(iterator.moveNext()))
1157 dart.throw(IterableElementError.noElement());
1158 let value = iterator.current;
1159 while (dart.notNull(iterator.moveNext())) {
1160 value = dart.dcall(combine, value, iterator.current);
1161 }
1162 return value;
1163 }
1164 static fold(iterable, initialValue, combine) {
1165 dart.as(combine, dart.functionType(dart.dynamic, [dart.dynamic, dart.dyn amic]));
1166 for (let element of iterable) {
1167 initialValue = dart.dcall(combine, initialValue, element);
1168 }
1169 return initialValue;
1170 }
1171 static removeWhereList(list, test) {
1172 dart.as(test, dart.functionType(core.bool, [dart.dynamic]));
1173 let retained = [];
1174 let length = list[dartx.length];
1175 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull (i) + 1) {
1176 let element = list[dartx.get](i);
1177 if (!dart.notNull(dart.dcall(test, element))) {
1178 retained[dartx.add](element);
1179 }
1180 if (length != list[dartx.length]) {
1181 dart.throw(new core.ConcurrentModificationError(list));
1182 }
1183 }
1184 if (retained[dartx.length] == length)
1185 return;
1186 list[dartx.length] = retained[dartx.length];
1187 for (let i = 0; dart.notNull(i) < dart.notNull(retained[dartx.length]); i = dart.notNull(i) + 1) {
1188 list[dartx.set](i, retained[dartx.get](i));
1189 }
1190 }
1191 static isEmpty(iterable) {
1192 return !dart.notNull(iterable[dartx.iterator].moveNext());
1193 }
1194 static first(iterable) {
1195 let it = iterable[dartx.iterator];
1196 if (!dart.notNull(it.moveNext())) {
1197 dart.throw(IterableElementError.noElement());
1198 }
1199 return it.current;
1200 }
1201 static last(iterable) {
1202 let it = iterable[dartx.iterator];
1203 if (!dart.notNull(it.moveNext())) {
1204 dart.throw(IterableElementError.noElement());
1205 }
1206 let result = null;
1207 do {
1208 result = it.current;
1209 } while (dart.notNull(it.moveNext()));
1210 return result;
1211 }
1212 static single(iterable) {
1213 let it = iterable[dartx.iterator];
1214 if (!dart.notNull(it.moveNext()))
1215 dart.throw(IterableElementError.noElement());
1216 let result = it.current;
1217 if (dart.notNull(it.moveNext()))
1218 dart.throw(IterableElementError.tooMany());
1219 return result;
1220 }
1221 static firstWhere(iterable, test, orElse) {
1222 dart.as(test, dart.functionType(core.bool, [dart.dynamic]));
1223 dart.as(orElse, dart.functionType(dart.dynamic, []));
1224 for (let element of iterable) {
1225 if (dart.notNull(dart.dcall(test, element)))
1226 return element;
1227 }
1228 if (orElse != null)
1229 return orElse();
1230 dart.throw(IterableElementError.noElement());
1231 }
1232 static lastWhere(iterable, test, orElse) {
1233 dart.as(test, dart.functionType(core.bool, [dart.dynamic]));
1234 dart.as(orElse, dart.functionType(dart.dynamic, []));
1235 let result = null;
1236 let foundMatching = false;
1237 for (let element of iterable) {
1238 if (dart.notNull(dart.dcall(test, element))) {
1239 result = element;
1240 foundMatching = true;
1241 }
1242 }
1243 if (dart.notNull(foundMatching))
1244 return result;
1245 if (orElse != null)
1246 return orElse();
1247 dart.throw(IterableElementError.noElement());
1248 }
1249 static lastWhereList(list, test, orElse) {
1250 dart.as(test, dart.functionType(core.bool, [dart.dynamic]));
1251 dart.as(orElse, dart.functionType(dart.dynamic, []));
1252 for (let i = dart.notNull(list[dartx.length]) - 1; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
1253 let element = list[dartx.get](i);
1254 if (dart.notNull(dart.dcall(test, element)))
1255 return element;
1256 }
1257 if (orElse != null)
1258 return orElse();
1259 dart.throw(IterableElementError.noElement());
1260 }
1261 static singleWhere(iterable, test) {
1262 dart.as(test, dart.functionType(core.bool, [dart.dynamic]));
1263 let result = null;
1264 let foundMatching = false;
1265 for (let element of iterable) {
1266 if (dart.notNull(dart.dcall(test, element))) {
1267 if (dart.notNull(foundMatching)) {
1268 dart.throw(IterableElementError.tooMany());
1269 }
1270 result = element;
1271 foundMatching = true;
1272 }
1273 }
1274 if (dart.notNull(foundMatching))
1275 return result;
1276 dart.throw(IterableElementError.noElement());
1277 }
1278 static elementAt(iterable, index) {
1279 if (!(typeof index == 'number'))
1280 dart.throw(new core.ArgumentError.notNull("index"));
1281 core.RangeError.checkNotNegative(index, "index");
1282 let elementIndex = 0;
1283 for (let element of iterable) {
1284 if (index == elementIndex)
1285 return element;
1286 elementIndex = dart.notNull(elementIndex) + 1;
1287 }
1288 dart.throw(core.RangeError.index(index, iterable, "index", null, element Index));
1289 }
1290 static join(iterable, separator) {
1291 if (separator === void 0)
1292 separator = null;
1293 let buffer = new core.StringBuffer();
1294 buffer.writeAll(iterable, separator);
1295 return dart.toString(buffer);
1296 }
1297 static joinList(list, separator) {
1298 if (separator === void 0)
1299 separator = null;
1300 if (dart.notNull(list[dartx.isEmpty]))
1301 return "";
1302 if (list[dartx.length] == 1)
1303 return `${list[dartx.get](0)}`;
1304 let buffer = new core.StringBuffer();
1305 if (dart.notNull(separator[dartx.isEmpty])) {
1306 for (let i = 0; dart.notNull(i) < dart.notNull(list[dartx.length]); i = dart.notNull(i) + 1) {
1307 buffer.write(list[dartx.get](i));
1308 }
1309 } else {
1310 buffer.write(list[dartx.get](0));
1311 for (let i = 1; dart.notNull(i) < dart.notNull(list[dartx.length]); i = dart.notNull(i) + 1) {
1312 buffer.write(separator);
1313 buffer.write(list[dartx.get](i));
1314 }
1315 }
1316 return dart.toString(buffer);
1317 }
1318 where(iterable, f) {
1319 dart.as(f, dart.functionType(core.bool, [dart.dynamic]));
1320 return new (WhereIterable$(T))(dart.as(iterable, core.Iterable$(T)), dar t.as(f, __CastType2));
1321 }
1322 static map(iterable, f) {
1323 dart.as(f, dart.functionType(dart.dynamic, [dart.dynamic]));
1324 return MappedIterable.new(iterable, f);
1325 }
1326 static mapList(list, f) {
1327 dart.as(f, dart.functionType(dart.dynamic, [dart.dynamic]));
1328 return new MappedListIterable(list, f);
1329 }
1330 static expand(iterable, f) {
1331 dart.as(f, dart.functionType(core.Iterable, [dart.dynamic]));
1332 return new ExpandIterable(iterable, f);
1333 }
1334 takeList(list, n) {
1335 return new (SubListIterable$(T))(dart.as(list, core.Iterable$(T)), 0, n) ;
1336 }
1337 takeWhile(iterable, test) {
1338 dart.as(test, dart.functionType(core.bool, [dart.dynamic]));
1339 return new (TakeWhileIterable$(T))(dart.as(iterable, core.Iterable$(T)), dart.as(test, dart.functionType(core.bool, [T])));
1340 }
1341 skipList(list, n) {
1342 return new (SubListIterable$(T))(dart.as(list, core.Iterable$(T)), n, nu ll);
1343 }
1344 skipWhile(iterable, test) {
1345 dart.as(test, dart.functionType(core.bool, [dart.dynamic]));
1346 return new (SkipWhileIterable$(T))(dart.as(iterable, core.Iterable$(T)), dart.as(test, dart.functionType(core.bool, [T])));
1347 }
1348 reversedList(list) {
1349 return new (ReversedListIterable$(T))(dart.as(list, core.Iterable$(T)));
1350 }
1351 static sortList(list, compare) {
1352 dart.as(compare, dart.functionType(core.int, [dart.dynamic, dart.dynamic ]));
1353 if (compare == null)
1354 compare = core.Comparable.compare;
1355 Sort.sort(list, compare);
1356 }
1357 static shuffleList(list, random) {
1358 if (random == null)
1359 random = math.Random.new();
1360 let length = list[dartx.length];
1361 while (dart.notNull(length) > 1) {
1362 let pos = random.nextInt(length);
1363 length = dart.notNull(length) - 1;
1364 let tmp = list[dartx.get](length);
1365 list[dartx.set](length, list[dartx.get](pos));
1366 list[dartx.set](pos, tmp);
1367 }
1368 }
1369 static indexOfList(list, element, start) {
1370 return Lists.indexOf(list, element, start, list[dartx.length]);
1371 }
1372 static lastIndexOfList(list, element, start) {
1373 if (start == null)
1374 start = dart.notNull(list[dartx.length]) - 1;
1375 return Lists.lastIndexOf(list, element, start);
1376 }
1377 static _rangeCheck(list, start, end) {
1378 core.RangeError.checkValidRange(start, end, list[dartx.length]);
1379 }
1380 getRangeList(list, start, end) {
1381 IterableMixinWorkaround$()._rangeCheck(list, start, end);
1382 return new (SubListIterable$(T))(dart.as(list, core.Iterable$(T)), start , end);
1383 }
1384 static setRangeList(list, start, end, from, skipCount) {
1385 IterableMixinWorkaround$()._rangeCheck(list, start, end);
1386 let length = dart.notNull(end) - dart.notNull(start);
1387 if (length == 0)
1388 return;
1389 if (dart.notNull(skipCount) < 0)
1390 dart.throw(new core.ArgumentError(skipCount));
1391 let otherList = null;
1392 let otherStart = null;
1393 if (dart.is(from, core.List)) {
1394 otherList = from;
1395 otherStart = skipCount;
1396 } else {
1397 otherList = from[dartx.skip](skipCount)[dartx.toList]({growable: false });
1398 otherStart = 0;
1399 }
1400 if (dart.notNull(otherStart) + dart.notNull(length) > dart.notNull(other List[dartx.length])) {
1401 dart.throw(IterableElementError.tooFew());
1402 }
1403 Lists.copy(otherList, otherStart, list, start, length);
1404 }
1405 static replaceRangeList(list, start, end, iterable) {
1406 IterableMixinWorkaround$()._rangeCheck(list, start, end);
1407 if (!dart.is(iterable, EfficientLength)) {
1408 iterable = iterable[dartx.toList]();
1409 }
1410 let removeLength = dart.notNull(end) - dart.notNull(start);
1411 let insertLength = iterable[dartx.length];
1412 if (dart.notNull(removeLength) >= dart.notNull(insertLength)) {
1413 let delta = dart.notNull(removeLength) - dart.notNull(insertLength);
1414 let insertEnd = dart.notNull(start) + dart.notNull(insertLength);
1415 let newEnd = dart.notNull(list[dartx.length]) - dart.notNull(delta);
1416 list[dartx.setRange](start, insertEnd, iterable);
1417 if (delta != 0) {
1418 list[dartx.setRange](insertEnd, newEnd, list, end);
1419 list[dartx.length] = newEnd;
1420 }
1421 } else {
1422 let delta = dart.notNull(insertLength) - dart.notNull(removeLength);
1423 let newLength = dart.notNull(list[dartx.length]) + dart.notNull(delta) ;
1424 let insertEnd = dart.notNull(start) + dart.notNull(insertLength);
1425 list[dartx.length] = newLength;
1426 list[dartx.setRange](insertEnd, newLength, list, end);
1427 list[dartx.setRange](start, insertEnd, iterable);
1428 }
1429 }
1430 static fillRangeList(list, start, end, fillValue) {
1431 IterableMixinWorkaround$()._rangeCheck(list, start, end);
1432 for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNul l(i) + 1) {
1433 list[dartx.set](i, fillValue);
1434 }
1435 }
1436 static insertAllList(list, index, iterable) {
1437 core.RangeError.checkValueInInterval(index, 0, list[dartx.length], "inde x");
1438 if (!dart.is(iterable, EfficientLength)) {
1439 iterable = iterable[dartx.toList]({growable: false});
1440 }
1441 let insertionLength = iterable[dartx.length];
1442 list[dartx.length] = dart.notNull(list[dartx.length]) + dart.notNull(ins ertionLength);
1443 list[dartx.setRange](dart.notNull(index) + dart.notNull(insertionLength) , list[dartx.length], list, index);
1444 for (let element of iterable) {
1445 list[dartx.set]((() => {
1446 let x = index;
1447 index = dart.notNull(x) + 1;
1448 return x;
1449 })(), element);
1450 }
1451 }
1452 static setAllList(list, index, iterable) {
1453 core.RangeError.checkValueInInterval(index, 0, list[dartx.length], "inde x");
1454 for (let element of iterable) {
1455 list[dartx.set]((() => {
1456 let x = index;
1457 index = dart.notNull(x) + 1;
1458 return x;
1459 })(), element);
1460 }
1461 }
1462 asMapList(l) {
1463 return new (ListMapView$(T))(dart.as(l, core.List$(T)));
1464 }
1465 static setContainsAll(set, other) {
1466 for (let element of other) {
1467 if (!dart.notNull(set.contains(element)))
1468 return false;
1469 }
1470 return true;
1471 }
1472 static setIntersection(set, other, result) {
1473 let smaller = null;
1474 let larger = null;
1475 if (dart.notNull(set.length) < dart.notNull(other.length)) {
1476 smaller = set;
1477 larger = other;
1478 } else {
1479 smaller = other;
1480 larger = set;
1481 }
1482 for (let element of smaller) {
1483 if (dart.notNull(larger.contains(element))) {
1484 result.add(element);
1485 }
1486 }
1487 return result;
1488 }
1489 static setUnion(set, other, result) {
1490 result.addAll(set);
1491 result.addAll(other);
1492 return result;
1493 }
1494 static setDifference(set, other, result) {
1495 for (let element of set) {
1496 if (!dart.notNull(other.contains(element))) {
1497 result.add(element);
1498 }
1499 }
1500 return result;
1501 }
1502 }
1503 dart.setSignature(IterableMixinWorkaround, {
1504 methods: () => ({
1505 where: [core.Iterable$(T), [core.Iterable, dart.functionType(core.bool, [dart.dynamic])]],
1506 takeList: [core.Iterable$(T), [core.List, core.int]],
1507 takeWhile: [core.Iterable$(T), [core.Iterable, dart.functionType(core.bo ol, [dart.dynamic])]],
1508 skipList: [core.Iterable$(T), [core.List, core.int]],
1509 skipWhile: [core.Iterable$(T), [core.Iterable, dart.functionType(core.bo ol, [dart.dynamic])]],
1510 reversedList: [core.Iterable$(T), [core.List]],
1511 getRangeList: [core.Iterable$(T), [core.List, core.int, core.int]],
1512 asMapList: [core.Map$(core.int, T), [core.List]]
1513 }),
1514 statics: () => ({
1515 contains: [core.bool, [core.Iterable, dart.dynamic]],
1516 forEach: [dart.void, [core.Iterable, dart.functionType(dart.void, [dart. dynamic])]],
1517 any: [core.bool, [core.Iterable, dart.functionType(core.bool, [dart.dyna mic])]],
1518 every: [core.bool, [core.Iterable, dart.functionType(core.bool, [dart.dy namic])]],
1519 reduce: [dart.dynamic, [core.Iterable, dart.functionType(dart.dynamic, [ dart.dynamic, dart.dynamic])]],
1520 fold: [dart.dynamic, [core.Iterable, dart.dynamic, dart.functionType(dar t.dynamic, [dart.dynamic, dart.dynamic])]],
1521 removeWhereList: [dart.void, [core.List, dart.functionType(core.bool, [d art.dynamic])]],
1522 isEmpty: [core.bool, [core.Iterable]],
1523 first: [dart.dynamic, [core.Iterable]],
1524 last: [dart.dynamic, [core.Iterable]],
1525 single: [dart.dynamic, [core.Iterable]],
1526 firstWhere: [dart.dynamic, [core.Iterable, dart.functionType(core.bool, [dart.dynamic]), dart.functionType(dart.dynamic, [])]],
1527 lastWhere: [dart.dynamic, [core.Iterable, dart.functionType(core.bool, [ dart.dynamic]), dart.functionType(dart.dynamic, [])]],
1528 lastWhereList: [dart.dynamic, [core.List, dart.functionType(core.bool, [ dart.dynamic]), dart.functionType(dart.dynamic, [])]],
1529 singleWhere: [dart.dynamic, [core.Iterable, dart.functionType(core.bool, [dart.dynamic])]],
1530 elementAt: [dart.dynamic, [core.Iterable, core.int]],
1531 join: [core.String, [core.Iterable], [core.String]],
1532 joinList: [core.String, [core.List], [core.String]],
1533 map: [core.Iterable, [core.Iterable, dart.functionType(dart.dynamic, [da rt.dynamic])]],
1534 mapList: [core.Iterable, [core.List, dart.functionType(dart.dynamic, [da rt.dynamic])]],
1535 expand: [core.Iterable, [core.Iterable, dart.functionType(core.Iterable, [dart.dynamic])]],
1536 sortList: [dart.void, [core.List, dart.functionType(core.int, [dart.dyna mic, dart.dynamic])]],
1537 shuffleList: [dart.void, [core.List, math.Random]],
1538 indexOfList: [core.int, [core.List, dart.dynamic, core.int]],
1539 lastIndexOfList: [core.int, [core.List, dart.dynamic, core.int]],
1540 _rangeCheck: [dart.void, [core.List, core.int, core.int]],
1541 setRangeList: [dart.void, [core.List, core.int, core.int, core.Iterable, core.int]],
1542 replaceRangeList: [dart.void, [core.List, core.int, core.int, core.Itera ble]],
1543 fillRangeList: [dart.void, [core.List, core.int, core.int, dart.dynamic] ],
1544 insertAllList: [dart.void, [core.List, core.int, core.Iterable]],
1545 setAllList: [dart.void, [core.List, core.int, core.Iterable]],
1546 setContainsAll: [core.bool, [core.Set, core.Iterable]],
1547 setIntersection: [core.Set, [core.Set, core.Set, core.Set]],
1548 setUnion: [core.Set, [core.Set, core.Set, core.Set]],
1549 setDifference: [core.Set, [core.Set, core.Set, core.Set]]
1550 }),
1551 names: ['contains', 'forEach', 'any', 'every', 'reduce', 'fold', 'removeWh ereList', 'isEmpty', 'first', 'last', 'single', 'firstWhere', 'lastWhere', 'last WhereList', 'singleWhere', 'elementAt', 'join', 'joinList', 'map', 'mapList', 'e xpand', 'sortList', 'shuffleList', 'indexOfList', 'lastIndexOfList', '_rangeChec k', 'setRangeList', 'replaceRangeList', 'fillRangeList', 'insertAllList', 'setAl lList', 'setContainsAll', 'setIntersection', 'setUnion', 'setDifference']
1552 });
1553 return IterableMixinWorkaround;
1554 });
1555 let IterableMixinWorkaround = IterableMixinWorkaround$();
1556 class IterableElementError extends core.Object {
1557 static noElement() {
1558 return new core.StateError("No element");
1559 }
1560 static tooMany() {
1561 return new core.StateError("Too many elements");
1562 }
1563 static tooFew() {
1564 return new core.StateError("Too few elements");
1565 }
1566 }
1567 dart.setSignature(IterableElementError, {
1568 statics: () => ({
1569 noElement: [core.StateError, []],
1570 tooMany: [core.StateError, []],
1571 tooFew: [core.StateError, []]
1572 }),
1573 names: ['noElement', 'tooMany', 'tooFew']
1574 });
1575 let __CastType0$ = dart.generic(function(S, T) {
1576 let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(core.I terable$(T), [S]));
1577 return __CastType0;
1578 });
1579 let __CastType0 = __CastType0$();
1580 let __CastType2$ = dart.generic(function(T) {
1581 let __CastType2 = dart.typedef('__CastType2', () => dart.functionType(core.b ool, [T]));
1582 return __CastType2;
1583 });
1584 let __CastType2 = __CastType2$();
1585 let FixedLengthListMixin$ = dart.generic(function(E) {
1586 class FixedLengthListMixin extends core.Object {
1587 set length(newLength) {
1588 dart.throw(new core.UnsupportedError("Cannot change the length of a fixe d-length list"));
1589 }
1590 add(value) {
1591 dart.as(value, E);
1592 dart.throw(new core.UnsupportedError("Cannot add to a fixed-length list" ));
1593 }
1594 insert(index, value) {
1595 dart.as(value, E);
1596 dart.throw(new core.UnsupportedError("Cannot add to a fixed-length list" ));
1597 }
1598 insertAll(at, iterable) {
1599 dart.as(iterable, core.Iterable$(E));
1600 dart.throw(new core.UnsupportedError("Cannot add to a fixed-length list" ));
1601 }
1602 addAll(iterable) {
1603 dart.as(iterable, core.Iterable$(E));
1604 dart.throw(new core.UnsupportedError("Cannot add to a fixed-length list" ));
1605 }
1606 remove(element) {
1607 dart.throw(new core.UnsupportedError("Cannot remove from a fixed-length list"));
1608 }
1609 removeWhere(test) {
1610 dart.as(test, dart.functionType(core.bool, [E]));
1611 dart.throw(new core.UnsupportedError("Cannot remove from a fixed-length list"));
1612 }
1613 retainWhere(test) {
1614 dart.as(test, dart.functionType(core.bool, [E]));
1615 dart.throw(new core.UnsupportedError("Cannot remove from a fixed-length list"));
1616 }
1617 clear() {
1618 dart.throw(new core.UnsupportedError("Cannot clear a fixed-length list") );
1619 }
1620 removeAt(index) {
1621 dart.throw(new core.UnsupportedError("Cannot remove from a fixed-length list"));
1622 }
1623 removeLast() {
1624 dart.throw(new core.UnsupportedError("Cannot remove from a fixed-length list"));
1625 }
1626 removeRange(start, end) {
1627 dart.throw(new core.UnsupportedError("Cannot remove from a fixed-length list"));
1628 }
1629 replaceRange(start, end, iterable) {
1630 dart.as(iterable, core.Iterable$(E));
1631 dart.throw(new core.UnsupportedError("Cannot remove from a fixed-length list"));
1632 }
1633 }
1634 dart.setSignature(FixedLengthListMixin, {
1635 methods: () => ({
1636 add: [dart.void, [E]],
1637 insert: [dart.void, [core.int, E]],
1638 insertAll: [dart.void, [core.int, core.Iterable$(E)]],
1639 addAll: [dart.void, [core.Iterable$(E)]],
1640 remove: [core.bool, [core.Object]],
1641 removeWhere: [dart.void, [dart.functionType(core.bool, [E])]],
1642 retainWhere: [dart.void, [dart.functionType(core.bool, [E])]],
1643 clear: [dart.void, []],
1644 removeAt: [E, [core.int]],
1645 removeLast: [E, []],
1646 removeRange: [dart.void, [core.int, core.int]],
1647 replaceRange: [dart.void, [core.int, core.int, core.Iterable$(E)]]
1648 })
1649 });
1650 return FixedLengthListMixin;
1651 });
1652 let FixedLengthListMixin = FixedLengthListMixin$();
1653 let UnmodifiableListMixin$ = dart.generic(function(E) {
1654 class UnmodifiableListMixin extends core.Object {
1655 set(index, value) {
1656 dart.as(value, E);
1657 dart.throw(new core.UnsupportedError("Cannot modify an unmodifiable list "));
1658 return value;
1659 }
1660 set length(newLength) {
1661 dart.throw(new core.UnsupportedError("Cannot change the length of an unm odifiable list"));
1662 }
1663 setAll(at, iterable) {
1664 dart.as(iterable, core.Iterable$(E));
1665 dart.throw(new core.UnsupportedError("Cannot modify an unmodifiable list "));
1666 }
1667 add(value) {
1668 dart.as(value, E);
1669 dart.throw(new core.UnsupportedError("Cannot add to an unmodifiable list "));
1670 }
1671 insert(index, value) {
1672 dart.as(value, E);
1673 dart.throw(new core.UnsupportedError("Cannot add to an unmodifiable list "));
1674 }
1675 insertAll(at, iterable) {
1676 dart.as(iterable, core.Iterable$(E));
1677 dart.throw(new core.UnsupportedError("Cannot add to an unmodifiable list "));
1678 }
1679 addAll(iterable) {
1680 dart.as(iterable, core.Iterable$(E));
1681 dart.throw(new core.UnsupportedError("Cannot add to an unmodifiable list "));
1682 }
1683 remove(element) {
1684 dart.throw(new core.UnsupportedError("Cannot remove from an unmodifiable list"));
1685 }
1686 removeWhere(test) {
1687 dart.as(test, dart.functionType(core.bool, [E]));
1688 dart.throw(new core.UnsupportedError("Cannot remove from an unmodifiable list"));
1689 }
1690 retainWhere(test) {
1691 dart.as(test, dart.functionType(core.bool, [E]));
1692 dart.throw(new core.UnsupportedError("Cannot remove from an unmodifiable list"));
1693 }
1694 sort(compare) {
1695 if (compare === void 0)
1696 compare = null;
1697 dart.as(compare, core.Comparator$(E));
1698 dart.throw(new core.UnsupportedError("Cannot modify an unmodifiable list "));
1699 }
1700 shuffle(random) {
1701 if (random === void 0)
1702 random = null;
1703 dart.throw(new core.UnsupportedError("Cannot modify an unmodifiable list "));
1704 }
1705 clear() {
1706 dart.throw(new core.UnsupportedError("Cannot clear an unmodifiable list" ));
1707 }
1708 removeAt(index) {
1709 dart.throw(new core.UnsupportedError("Cannot remove from an unmodifiable list"));
1710 }
1711 removeLast() {
1712 dart.throw(new core.UnsupportedError("Cannot remove from an unmodifiable list"));
1713 }
1714 setRange(start, end, iterable, skipCount) {
1715 dart.as(iterable, core.Iterable$(E));
1716 if (skipCount === void 0)
1717 skipCount = 0;
1718 dart.throw(new core.UnsupportedError("Cannot modify an unmodifiable list "));
1719 }
1720 removeRange(start, end) {
1721 dart.throw(new core.UnsupportedError("Cannot remove from an unmodifiable list"));
1722 }
1723 replaceRange(start, end, iterable) {
1724 dart.as(iterable, core.Iterable$(E));
1725 dart.throw(new core.UnsupportedError("Cannot remove from an unmodifiable list"));
1726 }
1727 fillRange(start, end, fillValue) {
1728 if (fillValue === void 0)
1729 fillValue = null;
1730 dart.as(fillValue, E);
1731 dart.throw(new core.UnsupportedError("Cannot modify an unmodifiable list "));
1732 }
1733 }
1734 UnmodifiableListMixin[dart.implements] = () => [core.List$(E)];
1735 dart.setSignature(UnmodifiableListMixin, {
1736 methods: () => ({
1737 set: [dart.void, [core.int, E]],
1738 setAll: [dart.void, [core.int, core.Iterable$(E)]],
1739 add: [dart.void, [E]],
1740 insert: [E, [core.int, E]],
1741 insertAll: [dart.void, [core.int, core.Iterable$(E)]],
1742 addAll: [dart.void, [core.Iterable$(E)]],
1743 remove: [core.bool, [core.Object]],
1744 removeWhere: [dart.void, [dart.functionType(core.bool, [E])]],
1745 retainWhere: [dart.void, [dart.functionType(core.bool, [E])]],
1746 sort: [dart.void, [], [core.Comparator$(E)]],
1747 shuffle: [dart.void, [], [math.Random]],
1748 clear: [dart.void, []],
1749 removeAt: [E, [core.int]],
1750 removeLast: [E, []],
1751 setRange: [dart.void, [core.int, core.int, core.Iterable$(E)], [core.int ]],
1752 removeRange: [dart.void, [core.int, core.int]],
1753 replaceRange: [dart.void, [core.int, core.int, core.Iterable$(E)]],
1754 fillRange: [dart.void, [core.int, core.int], [E]]
1755 })
1756 });
1757 dart.defineExtensionMembers(UnmodifiableListMixin, [
1758 'set',
1759 'setAll',
1760 'add',
1761 'insert',
1762 'insertAll',
1763 'addAll',
1764 'remove',
1765 'removeWhere',
1766 'retainWhere',
1767 'sort',
1768 'shuffle',
1769 'clear',
1770 'removeAt',
1771 'removeLast',
1772 'setRange',
1773 'removeRange',
1774 'replaceRange',
1775 'fillRange',
1776 'length'
1777 ]);
1778 return UnmodifiableListMixin;
1779 });
1780 let UnmodifiableListMixin = UnmodifiableListMixin$();
1781 let FixedLengthListBase$ = dart.generic(function(E) {
1782 class FixedLengthListBase extends dart.mixin(collection.ListBase$(E), FixedL engthListMixin$(E)) {
1783 FixedLengthListBase() {
1784 super.ListBase(...arguments);
1785 }
1786 }
1787 return FixedLengthListBase;
1788 });
1789 let FixedLengthListBase = FixedLengthListBase$();
1790 let UnmodifiableListBase$ = dart.generic(function(E) {
1791 class UnmodifiableListBase extends dart.mixin(collection.ListBase$(E), Unmod ifiableListMixin$(E)) {
1792 UnmodifiableListBase() {
1793 super.ListBase(...arguments);
1794 }
1795 }
1796 return UnmodifiableListBase;
1797 });
1798 let UnmodifiableListBase = UnmodifiableListBase$();
1799 let _backedList = dart.JsSymbol('_backedList');
1800 class _ListIndicesIterable extends ListIterable$(core.int) {
1801 _ListIndicesIterable(backedList) {
1802 this[_backedList] = backedList;
1803 super.ListIterable();
1804 }
1805 get length() {
1806 return this[_backedList][dartx.length];
1807 }
1808 elementAt(index) {
1809 core.RangeError.checkValidIndex(index, this);
1810 return index;
1811 }
1812 }
1813 dart.setSignature(_ListIndicesIterable, {
1814 constructors: () => ({_ListIndicesIterable: [_ListIndicesIterable, [core.Lis t]]}),
1815 methods: () => ({elementAt: [core.int, [core.int]]})
1816 });
1817 dart.defineExtensionMembers(_ListIndicesIterable, ['elementAt', 'length']);
1818 let _values = dart.JsSymbol('_values');
1819 let ListMapView$ = dart.generic(function(E) {
1820 class ListMapView extends core.Object {
1821 ListMapView(values) {
1822 this[_values] = values;
1823 }
1824 get(key) {
1825 return dart.notNull(this.containsKey(key)) ? this[_values][dartx.get](da rt.as(key, core.int)) : null;
1826 }
1827 get length() {
1828 return this[_values][dartx.length];
1829 }
1830 get values() {
1831 return new (SubListIterable$(E))(this[_values], 0, null);
1832 }
1833 get keys() {
1834 return new _ListIndicesIterable(this[_values]);
1835 }
1836 get isEmpty() {
1837 return this[_values][dartx.isEmpty];
1838 }
1839 get isNotEmpty() {
1840 return this[_values][dartx.isNotEmpty];
1841 }
1842 containsValue(value) {
1843 return this[_values][dartx.contains](value);
1844 }
1845 containsKey(key) {
1846 return typeof key == 'number' && dart.notNull(key) >= 0 && dart.notNull( key) < dart.notNull(this.length);
1847 }
1848 forEach(f) {
1849 dart.as(f, dart.functionType(dart.void, [core.int, E]));
1850 let length = this[_values][dartx.length];
1851 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull (i) + 1) {
1852 f(i, this[_values][dartx.get](i));
1853 if (length != this[_values][dartx.length]) {
1854 dart.throw(new core.ConcurrentModificationError(this[_values]));
1855 }
1856 }
1857 }
1858 set(key, value) {
1859 dart.as(value, E);
1860 dart.throw(new core.UnsupportedError("Cannot modify an unmodifiable map" ));
1861 return value;
1862 }
1863 putIfAbsent(key, ifAbsent) {
1864 dart.as(ifAbsent, dart.functionType(E, []));
1865 dart.throw(new core.UnsupportedError("Cannot modify an unmodifiable map" ));
1866 }
1867 remove(key) {
1868 dart.throw(new core.UnsupportedError("Cannot modify an unmodifiable map" ));
1869 }
1870 clear() {
1871 dart.throw(new core.UnsupportedError("Cannot modify an unmodifiable map" ));
1872 }
1873 addAll(other) {
1874 dart.as(other, core.Map$(core.int, E));
1875 dart.throw(new core.UnsupportedError("Cannot modify an unmodifiable map" ));
1876 }
1877 toString() {
1878 return collection.Maps.mapToString(this);
1879 }
1880 }
1881 ListMapView[dart.implements] = () => [core.Map$(core.int, E)];
1882 dart.setSignature(ListMapView, {
1883 constructors: () => ({ListMapView: [ListMapView$(E), [core.List$(E)]]}),
1884 methods: () => ({
1885 get: [E, [core.Object]],
1886 containsValue: [core.bool, [core.Object]],
1887 containsKey: [core.bool, [core.Object]],
1888 forEach: [dart.void, [dart.functionType(dart.void, [core.int, E])]],
1889 set: [dart.void, [core.int, E]],
1890 putIfAbsent: [E, [core.int, dart.functionType(E, [])]],
1891 remove: [E, [core.Object]],
1892 clear: [dart.void, []],
1893 addAll: [dart.void, [core.Map$(core.int, E)]]
1894 })
1895 });
1896 return ListMapView;
1897 });
1898 let ListMapView = ListMapView$();
1899 let ReversedListIterable$ = dart.generic(function(E) {
1900 class ReversedListIterable extends ListIterable$(E) {
1901 ReversedListIterable(source) {
1902 this[_source] = source;
1903 super.ListIterable();
1904 }
1905 get length() {
1906 return this[_source][dartx.length];
1907 }
1908 elementAt(index) {
1909 return this[_source][dartx.elementAt](dart.notNull(this[_source][dartx.l ength]) - 1 - dart.notNull(index));
1910 }
1911 }
1912 dart.setSignature(ReversedListIterable, {
1913 constructors: () => ({ReversedListIterable: [ReversedListIterable$(E), [co re.Iterable$(E)]]}),
1914 methods: () => ({elementAt: [E, [core.int]]})
1915 });
1916 dart.defineExtensionMembers(ReversedListIterable, ['elementAt', 'length']);
1917 return ReversedListIterable;
1918 });
1919 let ReversedListIterable = ReversedListIterable$();
1920 class UnmodifiableListError extends core.Object {
1921 static add() {
1922 return new core.UnsupportedError("Cannot add to unmodifiable List");
1923 }
1924 static change() {
1925 return new core.UnsupportedError("Cannot change the content of an unmodifi able List");
1926 }
1927 static length() {
1928 return new core.UnsupportedError("Cannot change length of unmodifiable Lis t");
1929 }
1930 static remove() {
1931 return new core.UnsupportedError("Cannot remove from unmodifiable List");
1932 }
1933 }
1934 dart.setSignature(UnmodifiableListError, {
1935 statics: () => ({
1936 add: [core.UnsupportedError, []],
1937 change: [core.UnsupportedError, []],
1938 length: [core.UnsupportedError, []],
1939 remove: [core.UnsupportedError, []]
1940 }),
1941 names: ['add', 'change', 'length', 'remove']
1942 });
1943 class NonGrowableListError extends core.Object {
1944 static add() {
1945 return new core.UnsupportedError("Cannot add to non-growable List");
1946 }
1947 static length() {
1948 return new core.UnsupportedError("Cannot change length of non-growable Lis t");
1949 }
1950 static remove() {
1951 return new core.UnsupportedError("Cannot remove from non-growable List");
1952 }
1953 }
1954 dart.setSignature(NonGrowableListError, {
1955 statics: () => ({
1956 add: [core.UnsupportedError, []],
1957 length: [core.UnsupportedError, []],
1958 remove: [core.UnsupportedError, []]
1959 }),
1960 names: ['add', 'length', 'remove']
1961 });
1962 function makeListFixedLength(growableList) {
1963 _interceptors.JSArray.markFixedList(growableList);
1964 return growableList;
1965 }
1966 dart.fn(makeListFixedLength, core.List, [core.List]);
1967 class Lists extends core.Object {
1968 static copy(src, srcStart, dst, dstStart, count) {
1969 if (dart.notNull(srcStart) < dart.notNull(dstStart)) {
1970 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) {
1971 dst[dartx.set](j, src[dartx.get](i));
1972 }
1973 } else {
1974 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) {
1975 dst[dartx.set](j, src[dartx.get](i));
1976 }
1977 }
1978 }
1979 static areEqual(a, b) {
1980 if (dart.notNull(core.identical(a, b)))
1981 return true;
1982 if (!dart.is(b, core.List))
1983 return false;
1984 let length = a[dartx.length];
1985 if (!dart.equals(length, dart.dload(b, 'length')))
1986 return false;
1987 for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i ) + 1) {
1988 if (!dart.notNull(core.identical(a[dartx.get](i), dart.dindex(b, i))))
1989 return false;
1990 }
1991 return true;
1992 }
1993 static indexOf(a, element, startIndex, endIndex) {
1994 if (dart.notNull(startIndex) >= dart.notNull(a[dartx.length])) {
1995 return -1;
1996 }
1997 if (dart.notNull(startIndex) < 0) {
1998 startIndex = 0;
1999 }
2000 for (let i = startIndex; dart.notNull(i) < dart.notNull(endIndex); i = dar t.notNull(i) + 1) {
2001 if (dart.equals(a[dartx.get](i), element)) {
2002 return i;
2003 }
2004 }
2005 return -1;
2006 }
2007 static lastIndexOf(a, element, startIndex) {
2008 if (dart.notNull(startIndex) < 0) {
2009 return -1;
2010 }
2011 if (dart.notNull(startIndex) >= dart.notNull(a[dartx.length])) {
2012 startIndex = dart.notNull(a[dartx.length]) - 1;
2013 }
2014 for (let i = startIndex; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
2015 if (dart.equals(a[dartx.get](i), element)) {
2016 return i;
2017 }
2018 }
2019 return -1;
2020 }
2021 static indicesCheck(a, start, end) {
2022 core.RangeError.checkValidRange(start, end, a[dartx.length]);
2023 }
2024 static rangeCheck(a, start, length) {
2025 core.RangeError.checkNotNegative(length);
2026 core.RangeError.checkNotNegative(start);
2027 if (dart.notNull(start) + dart.notNull(length) > dart.notNull(a[dartx.leng th])) {
2028 let message = `${start} + ${length} must be in the range [0..${a[dartx.l ength]}]`;
2029 dart.throw(new core.RangeError.range(length, 0, dart.notNull(a[dartx.len gth]) - dart.notNull(start), "length", message));
2030 }
2031 }
2032 }
2033 dart.setSignature(Lists, {
2034 statics: () => ({
2035 copy: [dart.void, [core.List, core.int, core.List, core.int, core.int]],
2036 areEqual: [core.bool, [core.List, dart.dynamic]],
2037 indexOf: [core.int, [core.List, core.Object, core.int, core.int]],
2038 lastIndexOf: [core.int, [core.List, core.Object, core.int]],
2039 indicesCheck: [dart.void, [core.List, core.int, core.int]],
2040 rangeCheck: [dart.void, [core.List, core.int, core.int]]
2041 }),
2042 names: ['copy', 'areEqual', 'indexOf', 'lastIndexOf', 'indicesCheck', 'range Check']
2043 });
2044 exports.printToZone = null;
2045 function printToConsole(line) {
2046 _js_primitives.printString(`${line}`);
2047 }
2048 dart.fn(printToConsole, dart.void, [core.String]);
2049 class Sort extends core.Object {
2050 static sort(a, compare) {
2051 Sort._doSort(a, 0, dart.notNull(a[dartx.length]) - 1, compare);
2052 }
2053 static sortRange(a, from, to, compare) {
2054 if (dart.notNull(from) < 0 || dart.notNull(to) > dart.notNull(a[dartx.leng th]) || dart.notNull(to) < dart.notNull(from)) {
2055 dart.throw("OutOfRange");
2056 }
2057 Sort._doSort(a, from, dart.notNull(to) - 1, compare);
2058 }
2059 static _doSort(a, left, right, compare) {
2060 if (dart.notNull(right) - dart.notNull(left) <= dart.notNull(Sort._INSERTI ON_SORT_THRESHOLD)) {
2061 Sort._insertionSort(a, left, right, compare);
2062 } else {
2063 Sort._dualPivotQuicksort(a, left, right, compare);
2064 }
2065 }
2066 static _insertionSort(a, left, right, compare) {
2067 for (let i = dart.notNull(left) + 1; dart.notNull(i) <= dart.notNull(right ); i = dart.notNull(i) + 1) {
2068 let el = a[dartx.get](i);
2069 let j = i;
2070 while (dart.notNull(j) > dart.notNull(left) && dart.notNull(dart.dcall(c ompare, a[dartx.get](dart.notNull(j) - 1), el)) > 0) {
2071 a[dartx.set](j, a[dartx.get](dart.notNull(j) - 1));
2072 j = dart.notNull(j) - 1;
2073 }
2074 a[dartx.set](j, el);
2075 }
2076 }
2077 static _dualPivotQuicksort(a, left, right, compare) {
2078 dart.assert(dart.notNull(right) - dart.notNull(left) > dart.notNull(Sort._ INSERTION_SORT_THRESHOLD));
2079 let sixth = ((dart.notNull(right) - dart.notNull(left) + 1) / 6)[dartx.tru ncate]();
2080 let index1 = dart.notNull(left) + dart.notNull(sixth);
2081 let index5 = dart.notNull(right) - dart.notNull(sixth);
2082 let index3 = ((dart.notNull(left) + dart.notNull(right)) / 2)[dartx.trunca te]();
2083 let index2 = dart.notNull(index3) - dart.notNull(sixth);
2084 let index4 = dart.notNull(index3) + dart.notNull(sixth);
2085 let el1 = a[dartx.get](index1);
2086 let el2 = a[dartx.get](index2);
2087 let el3 = a[dartx.get](index3);
2088 let el4 = a[dartx.get](index4);
2089 let el5 = a[dartx.get](index5);
2090 if (dart.notNull(dart.dcall(compare, el1, el2)) > 0) {
2091 let t = el1;
2092 el1 = el2;
2093 el2 = t;
2094 }
2095 if (dart.notNull(dart.dcall(compare, el4, el5)) > 0) {
2096 let t = el4;
2097 el4 = el5;
2098 el5 = t;
2099 }
2100 if (dart.notNull(dart.dcall(compare, el1, el3)) > 0) {
2101 let t = el1;
2102 el1 = el3;
2103 el3 = t;
2104 }
2105 if (dart.notNull(dart.dcall(compare, el2, el3)) > 0) {
2106 let t = el2;
2107 el2 = el3;
2108 el3 = t;
2109 }
2110 if (dart.notNull(dart.dcall(compare, el1, el4)) > 0) {
2111 let t = el1;
2112 el1 = el4;
2113 el4 = t;
2114 }
2115 if (dart.notNull(dart.dcall(compare, el3, el4)) > 0) {
2116 let t = el3;
2117 el3 = el4;
2118 el4 = t;
2119 }
2120 if (dart.notNull(dart.dcall(compare, el2, el5)) > 0) {
2121 let t = el2;
2122 el2 = el5;
2123 el5 = t;
2124 }
2125 if (dart.notNull(dart.dcall(compare, el2, el3)) > 0) {
2126 let t = el2;
2127 el2 = el3;
2128 el3 = t;
2129 }
2130 if (dart.notNull(dart.dcall(compare, el4, el5)) > 0) {
2131 let t = el4;
2132 el4 = el5;
2133 el5 = t;
2134 }
2135 let pivot1 = el2;
2136 let pivot2 = el4;
2137 a[dartx.set](index1, el1);
2138 a[dartx.set](index3, el3);
2139 a[dartx.set](index5, el5);
2140 a[dartx.set](index2, a[dartx.get](left));
2141 a[dartx.set](index4, a[dartx.get](right));
2142 let less = dart.notNull(left) + 1;
2143 let great = dart.notNull(right) - 1;
2144 let pivots_are_equal = dart.dcall(compare, pivot1, pivot2) == 0;
2145 if (dart.notNull(pivots_are_equal)) {
2146 let pivot = pivot1;
2147 for (let k = less; dart.notNull(k) <= dart.notNull(great); k = dart.notN ull(k) + 1) {
2148 let ak = a[dartx.get](k);
2149 let comp = dart.dcall(compare, ak, pivot);
2150 if (comp == 0)
2151 continue;
2152 if (dart.notNull(comp) < 0) {
2153 if (k != less) {
2154 a[dartx.set](k, a[dartx.get](less));
2155 a[dartx.set](less, ak);
2156 }
2157 less = dart.notNull(less) + 1;
2158 } else {
2159 while (true) {
2160 comp = dart.dcall(compare, a[dartx.get](great), pivot);
2161 if (dart.notNull(comp) > 0) {
2162 great = dart.notNull(great) - 1;
2163 continue;
2164 } else if (dart.notNull(comp) < 0) {
2165 a[dartx.set](k, a[dartx.get](less));
2166 a[dartx.set]((() => {
2167 let x = less;
2168 less = dart.notNull(x) + 1;
2169 return x;
2170 })(), a[dartx.get](great));
2171 a[dartx.set]((() => {
2172 let x = great;
2173 great = dart.notNull(x) - 1;
2174 return x;
2175 })(), ak);
2176 break;
2177 } else {
2178 a[dartx.set](k, a[dartx.get](great));
2179 a[dartx.set]((() => {
2180 let x = great;
2181 great = dart.notNull(x) - 1;
2182 return x;
2183 })(), ak);
2184 break;
2185 }
2186 }
2187 }
2188 }
2189 } else {
2190 for (let k = less; dart.notNull(k) <= dart.notNull(great); k = dart.notN ull(k) + 1) {
2191 let ak = a[dartx.get](k);
2192 let comp_pivot1 = dart.dcall(compare, ak, pivot1);
2193 if (dart.notNull(comp_pivot1) < 0) {
2194 if (k != less) {
2195 a[dartx.set](k, a[dartx.get](less));
2196 a[dartx.set](less, ak);
2197 }
2198 less = dart.notNull(less) + 1;
2199 } else {
2200 let comp_pivot2 = dart.dcall(compare, ak, pivot2);
2201 if (dart.notNull(comp_pivot2) > 0) {
2202 while (true) {
2203 let comp = dart.dcall(compare, a[dartx.get](great), pivot2);
2204 if (dart.notNull(comp) > 0) {
2205 great = dart.notNull(great) - 1;
2206 if (dart.notNull(great) < dart.notNull(k))
2207 break;
2208 continue;
2209 } else {
2210 comp = dart.dcall(compare, a[dartx.get](great), pivot1);
2211 if (dart.notNull(comp) < 0) {
2212 a[dartx.set](k, a[dartx.get](less));
2213 a[dartx.set]((() => {
2214 let x = less;
2215 less = dart.notNull(x) + 1;
2216 return x;
2217 })(), a[dartx.get](great));
2218 a[dartx.set]((() => {
2219 let x = great;
2220 great = dart.notNull(x) - 1;
2221 return x;
2222 })(), ak);
2223 } else {
2224 a[dartx.set](k, a[dartx.get](great));
2225 a[dartx.set]((() => {
2226 let x = great;
2227 great = dart.notNull(x) - 1;
2228 return x;
2229 })(), ak);
2230 }
2231 break;
2232 }
2233 }
2234 }
2235 }
2236 }
2237 }
2238 a[dartx.set](left, a[dartx.get](dart.notNull(less) - 1));
2239 a[dartx.set](dart.notNull(less) - 1, pivot1);
2240 a[dartx.set](right, a[dartx.get](dart.notNull(great) + 1));
2241 a[dartx.set](dart.notNull(great) + 1, pivot2);
2242 Sort._doSort(a, left, dart.notNull(less) - 2, compare);
2243 Sort._doSort(a, dart.notNull(great) + 2, right, compare);
2244 if (dart.notNull(pivots_are_equal)) {
2245 return;
2246 }
2247 if (dart.notNull(less) < dart.notNull(index1) && dart.notNull(great) > dar t.notNull(index5)) {
2248 while (dart.dcall(compare, a[dartx.get](less), pivot1) == 0) {
2249 less = dart.notNull(less) + 1;
2250 }
2251 while (dart.dcall(compare, a[dartx.get](great), pivot2) == 0) {
2252 great = dart.notNull(great) - 1;
2253 }
2254 for (let k = less; dart.notNull(k) <= dart.notNull(great); k = dart.notN ull(k) + 1) {
2255 let ak = a[dartx.get](k);
2256 let comp_pivot1 = dart.dcall(compare, ak, pivot1);
2257 if (comp_pivot1 == 0) {
2258 if (k != less) {
2259 a[dartx.set](k, a[dartx.get](less));
2260 a[dartx.set](less, ak);
2261 }
2262 less = dart.notNull(less) + 1;
2263 } else {
2264 let comp_pivot2 = dart.dcall(compare, ak, pivot2);
2265 if (comp_pivot2 == 0) {
2266 while (true) {
2267 let comp = dart.dcall(compare, a[dartx.get](great), pivot2);
2268 if (comp == 0) {
2269 great = dart.notNull(great) - 1;
2270 if (dart.notNull(great) < dart.notNull(k))
2271 break;
2272 continue;
2273 } else {
2274 comp = dart.dcall(compare, a[dartx.get](great), pivot1);
2275 if (dart.notNull(comp) < 0) {
2276 a[dartx.set](k, a[dartx.get](less));
2277 a[dartx.set]((() => {
2278 let x = less;
2279 less = dart.notNull(x) + 1;
2280 return x;
2281 })(), a[dartx.get](great));
2282 a[dartx.set]((() => {
2283 let x = great;
2284 great = dart.notNull(x) - 1;
2285 return x;
2286 })(), ak);
2287 } else {
2288 a[dartx.set](k, a[dartx.get](great));
2289 a[dartx.set]((() => {
2290 let x = great;
2291 great = dart.notNull(x) - 1;
2292 return x;
2293 })(), ak);
2294 }
2295 break;
2296 }
2297 }
2298 }
2299 }
2300 }
2301 Sort._doSort(a, less, great, compare);
2302 } else {
2303 Sort._doSort(a, less, great, compare);
2304 }
2305 }
2306 }
2307 dart.setSignature(Sort, {
2308 statics: () => ({
2309 sort: [dart.void, [core.List, dart.functionType(core.int, [dart.dynamic, d art.dynamic])]],
2310 sortRange: [dart.void, [core.List, core.int, core.int, dart.functionType(c ore.int, [dart.dynamic, dart.dynamic])]],
2311 _doSort: [dart.void, [core.List, core.int, core.int, dart.functionType(cor e.int, [dart.dynamic, dart.dynamic])]],
2312 _insertionSort: [dart.void, [core.List, core.int, core.int, dart.functionT ype(core.int, [dart.dynamic, dart.dynamic])]],
2313 _dualPivotQuicksort: [dart.void, [core.List, core.int, core.int, dart.func tionType(core.int, [dart.dynamic, dart.dynamic])]]
2314 }),
2315 names: ['sort', 'sortRange', '_doSort', '_insertionSort', '_dualPivotQuickso rt']
2316 });
2317 Sort._INSERTION_SORT_THRESHOLD = 32;
2318 let _name = dart.JsSymbol('_name');
2319 class Symbol extends core.Object {
2320 Symbol(name) {
2321 this[_name] = name;
2322 }
2323 unvalidated(name) {
2324 this[_name] = name;
2325 }
2326 validated(name) {
2327 this[_name] = Symbol.validatePublicSymbol(name);
2328 }
2329 ['=='](other) {
2330 return dart.is(other, Symbol) && this[_name] == other[_name];
2331 }
2332 get hashCode() {
2333 let arbitraryPrime = 664597;
2334 return 536870911 & dart.notNull(arbitraryPrime) * dart.notNull(dart.hashCo de(this[_name]));
2335 }
2336 toString() {
2337 return `Symbol("${this[_name]}")`;
2338 }
2339 static getName(symbol) {
2340 return symbol[_name];
2341 }
2342 static validatePublicSymbol(name) {
2343 if (dart.notNull(name[dartx.isEmpty]) || dart.notNull(Symbol.publicSymbolP attern.hasMatch(name)))
2344 return name;
2345 if (dart.notNull(name[dartx.startsWith]('_'))) {
2346 dart.throw(new core.ArgumentError(`"${name}" is a private identifier`));
2347 }
2348 dart.throw(new core.ArgumentError(`"${name}" is not a valid (qualified) sy mbol name`));
2349 }
2350 static isValidSymbol(name) {
2351 return dart.notNull(name[dartx.isEmpty]) || dart.notNull(Symbol.symbolPatt ern.hasMatch(name));
2352 }
2353 }
2354 Symbol[dart.implements] = () => [core.Symbol];
2355 dart.defineNamedConstructor(Symbol, 'unvalidated');
2356 dart.defineNamedConstructor(Symbol, 'validated');
2357 dart.setSignature(Symbol, {
2358 constructors: () => ({
2359 Symbol: [Symbol, [core.String]],
2360 unvalidated: [Symbol, [core.String]],
2361 validated: [Symbol, [core.String]]
2362 }),
2363 methods: () => ({'==': [core.bool, [core.Object]]}),
2364 statics: () => ({
2365 getName: [core.String, [Symbol]],
2366 validatePublicSymbol: [core.String, [core.String]],
2367 isValidSymbol: [core.bool, [core.String]]
2368 }),
2369 names: ['getName', 'validatePublicSymbol', 'isValidSymbol']
2370 });
2371 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))';
2372 Symbol.publicIdentifierRE = '(?!' + `${Symbol.reservedWordRE}` + '\\b(?!\\$))[ a-zA-Z$][\\w$]*';
2373 Symbol.identifierRE = '(?!' + `${Symbol.reservedWordRE}` + '\\b(?!\\$))[a-zA-Z $_][\\w$]*';
2374 Symbol.operatorRE = '(?:[\\-+*/%&|^]|\\[\\]=?|==|~/?|<[<=]?|>[>=]?|unary-)';
2375 let POWERS_OF_TEN = dart.const([1.0, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1 000000.0, 10000000.0, 100000000.0, 1000000000.0, 10000000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0, 100000000000000.0, 1000000000000000.0, 100000 00000000000.0, 100000000000000000.0, 1000000000000000000.0, 10000000000000000000 .0, 100000000000000000000.0, 1e+21, 1e+22]);
2376 dart.defineLazyProperties(Symbol, {
2377 get publicSymbolPattern() {
2378 return core.RegExp.new(`^(?:${Symbol.operatorRE}$|${Symbol.publicIdentifie rRE}(?:=?$|[.](?!$)))+?$`);
2379 },
2380 get symbolPattern() {
2381 return core.RegExp.new(`^(?:${Symbol.operatorRE}$|${Symbol.identifierRE}(? :=?$|[.](?!$)))+?$`);
2382 }
2383 });
2384 // Exports:
2385 exports.EfficientLength = EfficientLength;
2386 exports.ListIterable$ = ListIterable$;
2387 exports.ListIterable = ListIterable;
2388 exports.SubListIterable$ = SubListIterable$;
2389 exports.SubListIterable = SubListIterable;
2390 exports.ListIterator$ = ListIterator$;
2391 exports.ListIterator = ListIterator;
2392 exports.MappedIterable$ = MappedIterable$;
2393 exports.MappedIterable = MappedIterable;
2394 exports.EfficientLengthMappedIterable$ = EfficientLengthMappedIterable$;
2395 exports.EfficientLengthMappedIterable = EfficientLengthMappedIterable;
2396 exports.MappedIterator$ = MappedIterator$;
2397 exports.MappedIterator = MappedIterator;
2398 exports.MappedListIterable$ = MappedListIterable$;
2399 exports.MappedListIterable = MappedListIterable;
2400 exports.WhereIterable$ = WhereIterable$;
2401 exports.WhereIterable = WhereIterable;
2402 exports.WhereIterator$ = WhereIterator$;
2403 exports.WhereIterator = WhereIterator;
2404 exports.ExpandIterable$ = ExpandIterable$;
2405 exports.ExpandIterable = ExpandIterable;
2406 exports.ExpandIterator$ = ExpandIterator$;
2407 exports.ExpandIterator = ExpandIterator;
2408 exports.TakeIterable$ = TakeIterable$;
2409 exports.TakeIterable = TakeIterable;
2410 exports.EfficientLengthTakeIterable$ = EfficientLengthTakeIterable$;
2411 exports.EfficientLengthTakeIterable = EfficientLengthTakeIterable;
2412 exports.TakeIterator$ = TakeIterator$;
2413 exports.TakeIterator = TakeIterator;
2414 exports.TakeWhileIterable$ = TakeWhileIterable$;
2415 exports.TakeWhileIterable = TakeWhileIterable;
2416 exports.TakeWhileIterator$ = TakeWhileIterator$;
2417 exports.TakeWhileIterator = TakeWhileIterator;
2418 exports.SkipIterable$ = SkipIterable$;
2419 exports.SkipIterable = SkipIterable;
2420 exports.EfficientLengthSkipIterable$ = EfficientLengthSkipIterable$;
2421 exports.EfficientLengthSkipIterable = EfficientLengthSkipIterable;
2422 exports.SkipIterator$ = SkipIterator$;
2423 exports.SkipIterator = SkipIterator;
2424 exports.SkipWhileIterable$ = SkipWhileIterable$;
2425 exports.SkipWhileIterable = SkipWhileIterable;
2426 exports.SkipWhileIterator$ = SkipWhileIterator$;
2427 exports.SkipWhileIterator = SkipWhileIterator;
2428 exports.EmptyIterable$ = EmptyIterable$;
2429 exports.EmptyIterable = EmptyIterable;
2430 exports.EmptyIterator$ = EmptyIterator$;
2431 exports.EmptyIterator = EmptyIterator;
2432 exports.BidirectionalIterator$ = BidirectionalIterator$;
2433 exports.BidirectionalIterator = BidirectionalIterator;
2434 exports.IterableMixinWorkaround$ = IterableMixinWorkaround$;
2435 exports.IterableMixinWorkaround = IterableMixinWorkaround;
2436 exports.IterableElementError = IterableElementError;
2437 exports.FixedLengthListMixin$ = FixedLengthListMixin$;
2438 exports.FixedLengthListMixin = FixedLengthListMixin;
2439 exports.UnmodifiableListMixin$ = UnmodifiableListMixin$;
2440 exports.UnmodifiableListMixin = UnmodifiableListMixin;
2441 exports.FixedLengthListBase$ = FixedLengthListBase$;
2442 exports.FixedLengthListBase = FixedLengthListBase;
2443 exports.UnmodifiableListBase$ = UnmodifiableListBase$;
2444 exports.UnmodifiableListBase = UnmodifiableListBase;
2445 exports.ListMapView$ = ListMapView$;
2446 exports.ListMapView = ListMapView;
2447 exports.ReversedListIterable$ = ReversedListIterable$;
2448 exports.ReversedListIterable = ReversedListIterable;
2449 exports.UnmodifiableListError = UnmodifiableListError;
2450 exports.NonGrowableListError = NonGrowableListError;
2451 exports.makeListFixedLength = makeListFixedLength;
2452 exports.Lists = Lists;
2453 exports.printToConsole = printToConsole;
2454 exports.Sort = Sort;
2455 exports.Symbol = Symbol;
2456 exports.POWERS_OF_TEN = POWERS_OF_TEN;
2457 });
OLDNEW
« no previous file with comments | « lib/runtime/dart/_interceptors.js ('k') | lib/runtime/dart/_isolate_helper.js » ('j') | lib/src/checker/resolver.dart » ('J')

Powered by Google App Engine
This is Rietveld 408576698