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

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: test/codegen/expect/dart/async.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/_native_typed_data.js ('k') | test/codegen/expect/dart/collection.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 async;
2 (function(exports) {
3 'use strict';
4 // Function _invokeErrorHandler: (Function, Object, StackTrace) → dynamic
5 function _invokeErrorHandler(errorHandler, error, stackTrace) {
6 if (dart.is(errorHandler, ZoneBinaryCallback)) {
7 return dart.dinvokef(errorHandler, error, stackTrace);
8 } else {
9 return dart.dinvokef(errorHandler, error);
10 }
11 }
12 // Function _registerErrorHandler: (Function, Zone) → Function
13 function _registerErrorHandler(errorHandler, zone) {
14 if (dart.is(errorHandler, ZoneBinaryCallback)) {
15 return zone.registerBinaryCallback(errorHandler);
16 } else {
17 return zone.registerUnaryCallback(dart.as(errorHandler, dart.throw_("Unimp lemented type (dynamic) → dynamic")));
18 }
19 }
20 let _getBestStackTrace = Symbol('_getBestStackTrace');
21 class AsyncError extends core.Object {
22 AsyncError(error, stackTrace) {
23 this.error = error;
24 this.stackTrace = stackTrace;
25 }
26 toString() {
27 return dart.as(dart.dinvoke(this.error, 'toString'), core.String);
28 }
29 }
30 class _UncaughtAsyncError extends AsyncError {
31 _UncaughtAsyncError(error, stackTrace) {
32 super.AsyncError(error, _getBestStackTrace(error, stackTrace));
33 }
34 static [_getBestStackTrace](error, stackTrace) {
35 if (stackTrace !== null)
36 return stackTrace;
37 if (dart.is(error, core.Error)) {
38 return dart.as(dart.dload(error, 'stackTrace'), core.StackTrace);
39 }
40 return null;
41 }
42 toString() {
43 let result = `Uncaught Error: ${this.error}`;
44 if (this.stackTrace !== null) {
45 result = `\nStack Trace:\n${this.stackTrace}`;
46 }
47 return result;
48 }
49 }
50 let _controller = Symbol('_controller');
51 let _createSubscription = Symbol('_createSubscription');
52 let _onListen = Symbol('_onListen');
53 let _addError = Symbol('_addError');
54 let _completeError = Symbol('_completeError');
55 let _complete = Symbol('_complete');
56 let _sink = Symbol('_sink');
57 let Stream$ = dart.generic(function(T) {
58 class Stream extends core.Object {
59 Stream() {
60 }
61 Stream$fromFuture(future) {
62 let controller = dart.as(new StreamController({sync: true}), _StreamCont roller$(T));
63 future.then(dart.closureWrap(((value) => {
64 controller._add(dart.as(value, T));
65 controller._closeUnchecked();
66 }).bind(this), "(T) → dynamic"), {onError: ((error, stackTrace) => {
67 controller._addError(error, dart.as(stackTrace, core.StackTrace));
68 controller._closeUnchecked();
69 }).bind(this)});
70 return controller.stream;
71 }
72 Stream$fromIterable(data) {
73 return new _GeneratedStreamImpl(() => new _IterablePendingEvents(data));
74 }
75 Stream$periodic(period, computation) {
76 if (computation === void 0)
77 computation = null;
78 if (computation === null)
79 computation = dart.closureWrap((i) => null, "(int) → T");
80 let timer = null;
81 let computationCount = 0;
82 let controller = null;
83 let watch = new core.Stopwatch();
84 // Function sendEvent: () → void
85 function sendEvent() {
86 watch.reset();
87 let data = computation((($tmp) => computationCount = dart.notNull($tmp ) + 1, $tmp)(computationCount));
88 controller.add(data);
89 }
90 // Function startPeriodicTimer: () → void
91 function startPeriodicTimer() {
92 dart.assert(timer === null);
93 timer = new Timer.periodic(period, (timer) => {
94 sendEvent();
95 });
96 }
97 controller = new StreamController({sync: true, onListen: (() => {
98 watch.start();
99 startPeriodicTimer();
100 }).bind(this), onPause: (() => {
101 timer.cancel();
102 timer = null;
103 watch.stop();
104 }).bind(this), onResume: (() => {
105 dart.assert(timer === null);
106 let elapsed = watch.elapsed;
107 watch.start();
108 timer = new Timer(period['-'](elapsed), () => {
109 timer = null;
110 startPeriodicTimer();
111 sendEvent();
112 });
113 }).bind(this), onCancel: (() => {
114 if (timer !== null)
115 timer.cancel();
116 timer = null;
117 }).bind(this)});
118 return controller.stream;
119 }
120 Stream$eventTransformed(source, mapSink) {
121 return dart.as(new _BoundSinkStream(source, dart.closureWrap(mapSink, "( EventSink<dynamic>) → EventSink")), Stream$(T));
122 }
123 get isBroadcast() {
124 return false;
125 }
126 asBroadcastStream(opt$) {
127 let onListen = opt$.onListen === void 0 ? null : opt$.onListen;
128 let onCancel = opt$.onCancel === void 0 ? null : opt$.onCancel;
129 return new _AsBroadcastStream(this, dart.closureWrap(onListen, "(StreamS ubscription<dynamic>) → void"), dart.closureWrap(onCancel, "(StreamSubscription< dynamic>) → void"));
130 }
131 where(test) {
132 return new _WhereStream(this, test);
133 }
134 map(convert) {
135 return new _MapStream(this, convert);
136 }
137 asyncMap(convert) {
138 let controller = null;
139 let subscription = null;
140 // Function onListen: () → void
141 function onListen() {
142 let add = controller.add;
143 dart.assert(dart.notNull(dart.is(controller, _StreamController)) || da rt.notNull(dart.is(controller, _BroadcastStreamController)));
144 let eventSink = controller;
145 let addError = eventSink[_addError];
146 subscription = this.listen(((event) => {
147 let newValue = null;
148 try {
149 newValue = convert(event);
150 } catch (e) {
151 let s = dart.stackTrace(e);
152 controller.addError(e, s);
153 return;
154 }
155
156 if (dart.is(newValue, Future)) {
157 subscription.pause();
158 dart.dinvoke(dart.dinvoke(newValue, 'then', add, {onError: addErro r}), 'whenComplete', subscription.resume);
159 } else {
160 controller.add(newValue);
161 }
162 }).bind(this), {onError: dart.as(addError, core.Function), onDone: con troller.close});
163 }
164 if (this.isBroadcast) {
165 controller = new StreamController.broadcast({onListen: onListen, onCan cel: (() => {
166 subscription.cancel();
167 }).bind(this), sync: true});
168 } else {
169 controller = new StreamController({onListen: onListen, onPause: (() => {
170 subscription.pause();
171 }).bind(this), onResume: (() => {
172 subscription.resume();
173 }).bind(this), onCancel: (() => {
174 subscription.cancel();
175 }).bind(this), sync: true});
176 }
177 return controller.stream;
178 }
179 asyncExpand(convert) {
180 let controller = null;
181 let subscription = null;
182 // Function onListen: () → void
183 function onListen() {
184 dart.assert(dart.notNull(dart.is(controller, _StreamController)) || da rt.notNull(dart.is(controller, _BroadcastStreamController)));
185 let eventSink = controller;
186 subscription = this.listen(((event) => {
187 let newStream = null;
188 try {
189 newStream = convert(event);
190 } catch (e) {
191 let s = dart.stackTrace(e);
192 controller.addError(e, s);
193 return;
194 }
195
196 if (newStream !== null) {
197 subscription.pause();
198 controller.addStream(newStream).whenComplete(subscription.resume);
199 }
200 }).bind(this), {onError: dart.as(eventSink[_addError], core.Function), onDone: controller.close});
201 }
202 if (this.isBroadcast) {
203 controller = new StreamController.broadcast({onListen: onListen, onCan cel: (() => {
204 subscription.cancel();
205 }).bind(this), sync: true});
206 } else {
207 controller = new StreamController({onListen: onListen, onPause: (() => {
208 subscription.pause();
209 }).bind(this), onResume: (() => {
210 subscription.resume();
211 }).bind(this), onCancel: (() => {
212 subscription.cancel();
213 }).bind(this), sync: true});
214 }
215 return controller.stream;
216 }
217 handleError(onError, opt$) {
218 let test = opt$.test === void 0 ? null : opt$.test;
219 return new _HandleErrorStream(this, onError, test);
220 }
221 expand(convert) {
222 return new _ExpandStream(this, convert);
223 }
224 pipe(streamConsumer) {
225 return streamConsumer.addStream(this).then(((_) => streamConsumer.close( )).bind(this));
226 }
227 transform(streamTransformer) {
228 return streamTransformer.bind(this);
229 }
230 reduce(combine) {
231 let result = new _Future();
232 let seenFirst = false;
233 let value = null;
234 let subscription = null;
235 subscription = this.listen((element) => {
236 if (seenFirst) {
237 _runUserCode(() => combine(value, element), (newValue) => {
238 value = newValue;
239 }, dart.as(_cancelAndErrorClosure(subscription, result), dart.throw_ ("Unimplemented type (dynamic, StackTrace) → dynamic")));
240 } else {
241 value = element;
242 seenFirst = true;
243 }
244 }, {onError: result[_completeError], onDone: (() => {
245 if (!dart.notNull(seenFirst)) {
246 try {
247 throw _internal.IterableElementError.noElement();
248 } catch (e) {
249 let s = dart.stackTrace(e);
250 _completeWithErrorCallback(result, e, s);
251 }
252
253 } else {
254 result._complete(value);
255 }
256 }).bind(this), cancelOnError: true});
257 return result;
258 }
259 fold(initialValue, combine) {
260 let result = new _Future();
261 let value = initialValue;
262 let subscription = null;
263 subscription = this.listen((element) => {
264 _runUserCode(() => dart.dinvokef(combine, value, element), (newValue) => {
265 value = newValue;
266 }, dart.as(_cancelAndErrorClosure(subscription, result), dart.throw_(" Unimplemented type (dynamic, StackTrace) → dynamic")));
267 }, {onError: ((e, st) => {
268 result._completeError(e, dart.as(st, core.StackTrace));
269 }).bind(this), onDone: (() => {
270 result._complete(value);
271 }).bind(this), cancelOnError: true});
272 return result;
273 }
274 join(separator) {
275 if (separator === void 0)
276 separator = "";
277 let result = new _Future();
278 let buffer = new core.StringBuffer();
279 let subscription = null;
280 let first = true;
281 subscription = this.listen(((element) => {
282 if (!dart.notNull(first)) {
283 buffer.write(separator);
284 }
285 first = false;
286 try {
287 buffer.write(element);
288 } catch (e) {
289 let s = dart.stackTrace(e);
290 _cancelAndErrorWithReplacement(subscription, result, e, s);
291 }
292
293 }).bind(this), {onError: ((e) => {
294 result._completeError(e);
295 }).bind(this), onDone: (() => {
296 result._complete(buffer.toString());
297 }).bind(this), cancelOnError: true});
298 return result;
299 }
300 contains(needle) {
301 let future = new _Future();
302 let subscription = null;
303 subscription = this.listen((element) => {
304 _runUserCode(() => dart.equals(element, needle), (isMatch) => {
305 if (isMatch) {
306 _cancelAndValue(subscription, future, true);
307 }
308 }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_(" Unimplemented type (dynamic, StackTrace) → dynamic")));
309 }, {onError: future[_completeError], onDone: (() => {
310 future._complete(false);
311 }).bind(this), cancelOnError: true});
312 return future;
313 }
314 forEach(action) {
315 let future = new _Future();
316 let subscription = null;
317 subscription = this.listen((element) => {
318 _runUserCode(() => action(element), (_) => {
319 }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_(" Unimplemented type (dynamic, StackTrace) → dynamic")));
320 }, {onError: future[_completeError], onDone: (() => {
321 future._complete(null);
322 }).bind(this), cancelOnError: true});
323 return future;
324 }
325 every(test) {
326 let future = new _Future();
327 let subscription = null;
328 subscription = this.listen((element) => {
329 _runUserCode(() => test(element), (isMatch) => {
330 if (!dart.notNull(isMatch)) {
331 _cancelAndValue(subscription, future, false);
332 }
333 }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_(" Unimplemented type (dynamic, StackTrace) → dynamic")));
334 }, {onError: future[_completeError], onDone: (() => {
335 future._complete(true);
336 }).bind(this), cancelOnError: true});
337 return future;
338 }
339 any(test) {
340 let future = new _Future();
341 let subscription = null;
342 subscription = this.listen((element) => {
343 _runUserCode(() => test(element), (isMatch) => {
344 if (isMatch) {
345 _cancelAndValue(subscription, future, true);
346 }
347 }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_(" Unimplemented type (dynamic, StackTrace) → dynamic")));
348 }, {onError: future[_completeError], onDone: (() => {
349 future._complete(false);
350 }).bind(this), cancelOnError: true});
351 return future;
352 }
353 get length() {
354 let future = new _Future();
355 let count = 0;
356 this.listen(dart.closureWrap((_) => {
357 count = dart.notNull(count) + 1;
358 }, "(T) → void"), {onError: future[_completeError], onDone: (() => {
359 future._complete(count);
360 }).bind(this), cancelOnError: true});
361 return future;
362 }
363 get isEmpty() {
364 let future = new _Future();
365 let subscription = null;
366 subscription = this.listen(dart.closureWrap((_) => {
367 _cancelAndValue(subscription, future, false);
368 }, "(T) → void"), {onError: future[_completeError], onDone: (() => {
369 future._complete(true);
370 }).bind(this), cancelOnError: true});
371 return future;
372 }
373 toList() {
374 let result = new List.from([]);
375 let future = new _Future();
376 this.listen(((data) => {
377 result.add(data);
378 }).bind(this), {onError: future[_completeError], onDone: (() => {
379 future._complete(result);
380 }).bind(this), cancelOnError: true});
381 return future;
382 }
383 toSet() {
384 let result = new core.Set();
385 let future = new _Future();
386 this.listen(((data) => {
387 result.add(data);
388 }).bind(this), {onError: future[_completeError], onDone: (() => {
389 future._complete(result);
390 }).bind(this), cancelOnError: true});
391 return future;
392 }
393 drain(futureValue) {
394 if (futureValue === void 0)
395 futureValue = null;
396 return this.listen(null, {cancelOnError: true}).asFuture(futureValue);
397 }
398 take(count) {
399 return dart.as(new _TakeStream(this, count), Stream$(T));
400 }
401 takeWhile(test) {
402 return dart.as(new _TakeWhileStream(this, test), Stream$(T));
403 }
404 skip(count) {
405 return dart.as(new _SkipStream(this, count), Stream$(T));
406 }
407 skipWhile(test) {
408 return dart.as(new _SkipWhileStream(this, test), Stream$(T));
409 }
410 distinct(equals) {
411 if (equals === void 0)
412 equals = null;
413 return dart.as(new _DistinctStream(this, equals), Stream$(T));
414 }
415 get first() {
416 let future = new _Future();
417 let subscription = null;
418 subscription = this.listen((value) => {
419 _cancelAndValue(subscription, future, value);
420 }, {
421 onError: future[_completeError],
422 onDone: () => {
423 try {
424 throw _internal.IterableElementError.noElement();
425 } catch (e) {
426 let s = dart.stackTrace(e);
427 _completeWithErrorCallback(future, e, s);
428 }
429
430 },
431 cancelOnError: true
432 });
433 return future;
434 }
435 get last() {
436 let future = new _Future();
437 let result = null;
438 let foundResult = false;
439 let subscription = null;
440 subscription = this.listen((value) => {
441 foundResult = true;
442 result = value;
443 }, {onError: future[_completeError], onDone: (() => {
444 if (foundResult) {
445 future._complete(result);
446 return;
447 }
448 try {
449 throw _internal.IterableElementError.noElement();
450 } catch (e) {
451 let s = dart.stackTrace(e);
452 _completeWithErrorCallback(future, e, s);
453 }
454
455 }).bind(this), cancelOnError: true});
456 return future;
457 }
458 get single() {
459 let future = new _Future();
460 let result = null;
461 let foundResult = false;
462 let subscription = null;
463 subscription = this.listen((value) => {
464 if (foundResult) {
465 try {
466 throw _internal.IterableElementError.tooMany();
467 } catch (e) {
468 let s = dart.stackTrace(e);
469 _cancelAndErrorWithReplacement(subscription, future, e, s);
470 }
471
472 return;
473 }
474 foundResult = true;
475 result = value;
476 }, {onError: future[_completeError], onDone: (() => {
477 if (foundResult) {
478 future._complete(result);
479 return;
480 }
481 try {
482 throw _internal.IterableElementError.noElement();
483 } catch (e) {
484 let s = dart.stackTrace(e);
485 _completeWithErrorCallback(future, e, s);
486 }
487
488 }).bind(this), cancelOnError: true});
489 return future;
490 }
491 firstWhere(test, opt$) {
492 let defaultValue = opt$.defaultValue === void 0 ? null : opt$.defaultVal ue;
493 let future = new _Future();
494 let subscription = null;
495 subscription = this.listen((value) => {
496 _runUserCode(() => test(value), (isMatch) => {
497 if (isMatch) {
498 _cancelAndValue(subscription, future, value);
499 }
500 }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_(" Unimplemented type (dynamic, StackTrace) → dynamic")));
501 }, {onError: future[_completeError], onDone: (() => {
502 if (defaultValue !== null) {
503 _runUserCode(defaultValue, future[_complete], future[_completeErro r]);
504 return;
505 }
506 try {
507 throw _internal.IterableElementError.noElement();
508 } catch (e) {
509 let s = dart.stackTrace(e);
510 _completeWithErrorCallback(future, e, s);
511 }
512
513 }).bind(this), cancelOnError: true});
514 return future;
515 }
516 lastWhere(test, opt$) {
517 let defaultValue = opt$.defaultValue === void 0 ? null : opt$.defaultVal ue;
518 let future = new _Future();
519 let result = null;
520 let foundResult = false;
521 let subscription = null;
522 subscription = this.listen((value) => {
523 _runUserCode(() => true === test(value), (isMatch) => {
524 if (isMatch) {
525 foundResult = true;
526 result = value;
527 }
528 }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_(" Unimplemented type (dynamic, StackTrace) → dynamic")));
529 }, {onError: future[_completeError], onDone: (() => {
530 if (foundResult) {
531 future._complete(result);
532 return;
533 }
534 if (defaultValue !== null) {
535 _runUserCode(defaultValue, future[_complete], future[_completeErro r]);
536 return;
537 }
538 try {
539 throw _internal.IterableElementError.noElement();
540 } catch (e) {
541 let s = dart.stackTrace(e);
542 _completeWithErrorCallback(future, e, s);
543 }
544
545 }).bind(this), cancelOnError: true});
546 return future;
547 }
548 singleWhere(test) {
549 let future = new _Future();
550 let result = null;
551 let foundResult = false;
552 let subscription = null;
553 subscription = this.listen((value) => {
554 _runUserCode(() => true === test(value), (isMatch) => {
555 if (isMatch) {
556 if (foundResult) {
557 try {
558 throw _internal.IterableElementError.tooMany();
559 } catch (e) {
560 let s = dart.stackTrace(e);
561 _cancelAndErrorWithReplacement(subscription, future, e, s);
562 }
563
564 return;
565 }
566 foundResult = true;
567 result = value;
568 }
569 }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_(" Unimplemented type (dynamic, StackTrace) → dynamic")));
570 }, {onError: future[_completeError], onDone: (() => {
571 if (foundResult) {
572 future._complete(result);
573 return;
574 }
575 try {
576 throw _internal.IterableElementError.noElement();
577 } catch (e) {
578 let s = dart.stackTrace(e);
579 _completeWithErrorCallback(future, e, s);
580 }
581
582 }).bind(this), cancelOnError: true});
583 return future;
584 }
585 elementAt(index) {
586 if (dart.notNull(!(typeof index == number)) || dart.notNull(index) < 0)
587 throw new core.ArgumentError(index);
588 let future = new _Future();
589 let subscription = null;
590 let elementIndex = 0;
591 subscription = this.listen((value) => {
592 if (index === elementIndex) {
593 _cancelAndValue(subscription, future, value);
594 return;
595 }
596 elementIndex = 1;
597 }, {onError: future[_completeError], onDone: (() => {
598 future._completeError(new core.RangeError.index(index, this, "index" , null, elementIndex));
599 }).bind(this), cancelOnError: true});
600 return future;
601 }
602 timeout(timeLimit, opt$) {
603 let onTimeout = opt$.onTimeout === void 0 ? null : opt$.onTimeout;
604 let controller = null;
605 let subscription = null;
606 let timer = null;
607 let zone = null;
608 let timeout = null;
609 // Function onData: (T) → void
610 function onData(event) {
611 timer.cancel();
612 controller.add(event);
613 timer = zone.createTimer(timeLimit, dart.as(timeout, dart.throw_("Unim plemented type () → void")));
614 }
615 // Function onError: (dynamic, StackTrace) → void
616 function onError(error, stackTrace) {
617 timer.cancel();
618 dart.assert(dart.notNull(dart.is(controller, _StreamController)) || da rt.notNull(dart.is(controller, _BroadcastStreamController)));
619 let eventSink = controller;
620 dart.dinvoke(eventSink, '_addError', error, stackTrace);
621 timer = zone.createTimer(timeLimit, dart.as(timeout, dart.throw_("Unim plemented type () → void")));
622 }
623 // Function onDone: () → void
624 function onDone() {
625 timer.cancel();
626 controller.close();
627 }
628 // Function onListen: () → void
629 function onListen() {
630 zone = Zone.current;
631 if (onTimeout === null) {
632 timeout = (() => {
633 controller.addError(new TimeoutException("No stream event", timeLi mit), null);
634 }).bind(this);
635 } else {
636 onTimeout = dart.closureWrap(zone.registerUnaryCallback(onTimeout), "(EventSink<dynamic>) → void");
637 let wrapper = new _ControllerEventSinkWrapper(null);
638 timeout = (() => {
639 wrapper[_sink] = controller;
640 zone.runUnaryGuarded(onTimeout, wrapper);
641 wrapper[_sink] = null;
642 }).bind(this);
643 }
644 subscription = this.listen(onData, {onError: onError, onDone: onDone}) ;
645 timer = zone.createTimer(timeLimit, dart.as(timeout, dart.throw_("Unim plemented type () → void")));
646 }
647 // Function onCancel: () → Future<dynamic>
648 function onCancel() {
649 timer.cancel();
650 let result = subscription.cancel();
651 subscription = null;
652 return result;
653 }
654 controller = this.isBroadcast ? new _SyncBroadcastStreamController(onLis ten, onCancel) : new _SyncStreamController(onListen, (() => {
655 timer.cancel();
656 subscription.pause();
657 }).bind(this), (() => {
658 subscription.resume();
659 timer = zone.createTimer(timeLimit, dart.as(timeout, dart.throw_("Unim plemented type () → void")));
660 }).bind(this), onCancel);
661 return controller.stream;
662 }
663 }
664 dart.defineNamedConstructor(Stream, 'fromFuture');
665 dart.defineNamedConstructor(Stream, 'fromIterable');
666 dart.defineNamedConstructor(Stream, 'periodic');
667 dart.defineNamedConstructor(Stream, 'eventTransformed');
668 return Stream;
669 });
670 let Stream = Stream$(dart.dynamic);
671 let _StreamImpl$ = dart.generic(function(T) {
672 class _StreamImpl extends Stream$(T) {
673 listen(onData, opt$) {
674 let onError = opt$.onError === void 0 ? null : opt$.onError;
675 let onDone = opt$.onDone === void 0 ? null : opt$.onDone;
676 let cancelOnError = opt$.cancelOnError === void 0 ? null : opt$.cancelOn Error;
677 cancelOnError = core.identical(true, cancelOnError);
678 let subscription = this[_createSubscription](onData, onError, onDone, ca ncelOnError);
679 this[_onListen](subscription);
680 return dart.as(subscription, StreamSubscription$(T));
681 }
682 [_createSubscription](onData, onError, onDone, cancelOnError) {
683 return new _BufferingStreamSubscription(onData, onError, onDone, cancelO nError);
684 }
685 [_onListen](subscription) {}
686 }
687 return _StreamImpl;
688 });
689 let _StreamImpl = _StreamImpl$(dart.dynamic);
690 let _ControllerStream$ = dart.generic(function(T) {
691 class _ControllerStream extends _StreamImpl$(T) {
692 _ControllerStream($_controller) {
693 this[_controller] = $_controller;
694 super._StreamImpl();
695 }
696 [_createSubscription](onData, onError, onDone, cancelOnError) {
697 return this[_controller]._subscribe(onData, onError, onDone, cancelOnErr or);
698 }
699 get hashCode() {
700 return dart.notNull(this[_controller].hashCode) ^ 892482866;
701 }
702 ['=='](other) {
703 if (core.identical(this, other))
704 return true;
705 if (!dart.is(other, _ControllerStream))
706 return false;
707 let otherStream = dart.as(other, _ControllerStream);
708 return core.identical(otherStream[_controller], this[_controller]);
709 }
710 }
711 return _ControllerStream;
712 });
713 let _ControllerStream = _ControllerStream$(dart.dynamic);
714 let _BroadcastStream$ = dart.generic(function(T) {
715 class _BroadcastStream extends _ControllerStream$(T) {
716 _BroadcastStream(controller) {
717 super._ControllerStream(dart.as(controller, _StreamControllerLifecycle$( T)));
718 }
719 get isBroadcast() {
720 return true;
721 }
722 }
723 return _BroadcastStream;
724 });
725 let _BroadcastStream = _BroadcastStream$(dart.dynamic);
726 let _next = Symbol('_next');
727 let _previous = Symbol('_previous');
728 class _BroadcastSubscriptionLink extends core.Object {
729 _BroadcastSubscriptionLink() {
730 this[_next] = null;
731 this[_previous] = null;
732 }
733 }
734 let _eventState = Symbol('_eventState');
735 let _expectsEvent = Symbol('_expectsEvent');
736 let _toggleEventId = Symbol('_toggleEventId');
737 let _isFiring = Symbol('_isFiring');
738 let _setRemoveAfterFiring = Symbol('_setRemoveAfterFiring');
739 let _removeAfterFiring = Symbol('_removeAfterFiring');
740 let _onPause = Symbol('_onPause');
741 let _onResume = Symbol('_onResume');
742 let _onCancel = Symbol('_onCancel');
743 let _zone = Symbol('_zone');
744 let _state = Symbol('_state');
745 let _onData = Symbol('_onData');
746 let _onError = Symbol('_onError');
747 let _onDone = Symbol('_onDone');
748 let _cancelFuture = Symbol('_cancelFuture');
749 let _pending = Symbol('_pending');
750 let _setPendingEvents = Symbol('_setPendingEvents');
751 let _extractPending = Symbol('_extractPending');
752 let _isCanceled = Symbol('_isCanceled');
753 let _isPaused = Symbol('_isPaused');
754 let _isInputPaused = Symbol('_isInputPaused');
755 let _inCallback = Symbol('_inCallback');
756 let _guardCallback = Symbol('_guardCallback');
757 let _decrementPauseCount = Symbol('_decrementPauseCount');
758 let _hasPending = Symbol('_hasPending');
759 let _mayResumeInput = Symbol('_mayResumeInput');
760 let _cancel = Symbol('_cancel');
761 let _isClosed = Symbol('_isClosed');
762 let _waitsForCancel = Symbol('_waitsForCancel');
763 let _canFire = Symbol('_canFire');
764 let _cancelOnError = Symbol('_cancelOnError');
765 let _incrementPauseCount = Symbol('_incrementPauseCount');
766 let _add = Symbol('_add');
767 let _sendData = Symbol('_sendData');
768 let _addPending = Symbol('_addPending');
769 let _sendError = Symbol('_sendError');
770 let _close = Symbol('_close');
771 let _sendDone = Symbol('_sendDone');
772 let _checkState = Symbol('_checkState');
773 let _BufferingStreamSubscription$ = dart.generic(function(T) {
774 class _BufferingStreamSubscription extends core.Object {
775 _BufferingStreamSubscription(onData, onError, onDone, cancelOnError) {
776 this[_zone] = Zone.current;
777 this[_state] = cancelOnError ? _BufferingStreamSubscription._STATE_CANCE L_ON_ERROR : 0;
778 this[_onData] = null;
779 this[_onError] = null;
780 this[_onDone] = null;
781 this[_cancelFuture] = null;
782 this[_pending] = null;
783 this.onData(onData);
784 this.onError(onError);
785 this.onDone(onDone);
786 }
787 [_setPendingEvents](pendingEvents) {
788 dart.assert(this[_pending] === null);
789 if (pendingEvents === null)
790 return;
791 this[_pending] = pendingEvents;
792 if (!dart.notNull(pendingEvents.isEmpty)) {
793 this[_state] = _BufferingStreamSubscription._STATE_HAS_PENDING;
794 this[_pending].schedule(this);
795 }
796 }
797 [_extractPending]() {
798 dart.assert(this[_isCanceled]);
799 let events = this[_pending];
800 this[_pending] = null;
801 return events;
802 }
803 onData(handleData) {
804 if (handleData === null)
805 handleData = dart.closureWrap(_nullDataHandler, "(T) → void");
806 this[_onData] = dart.closureWrap(this[_zone].registerUnaryCallback(handl eData), "(T) → void");
807 }
808 onError(handleError) {
809 if (handleError === null)
810 handleError = _nullErrorHandler;
811 this[_onError] = _registerErrorHandler(handleError, this[_zone]);
812 }
813 onDone(handleDone) {
814 if (handleDone === null)
815 handleDone = _nullDoneHandler;
816 this[_onDone] = this[_zone].registerCallback(handleDone);
817 }
818 pause(resumeSignal) {
819 if (resumeSignal === void 0)
820 resumeSignal = null;
821 if (this[_isCanceled])
822 return;
823 let wasPaused = this[_isPaused];
824 let wasInputPaused = this[_isInputPaused];
825 this[_state] = dart.notNull(this[_state]) + dart.notNull(_BufferingStrea mSubscription._STATE_PAUSE_COUNT) | dart.notNull(_BufferingStreamSubscription._S TATE_INPUT_PAUSED);
826 if (resumeSignal !== null)
827 resumeSignal.whenComplete(this.resume);
828 if (!dart.notNull(wasPaused) && dart.notNull(this[_pending] !== null))
829 this[_pending].cancelSchedule();
830 if (!dart.notNull(wasInputPaused) && !dart.notNull(this[_inCallback]))
831 this[_guardCallback](this[_onPause]);
832 }
833 resume() {
834 if (this[_isCanceled])
835 return;
836 if (this[_isPaused]) {
837 this[_decrementPauseCount]();
838 if (!dart.notNull(this[_isPaused])) {
839 if (dart.notNull(this[_hasPending]) && !dart.notNull(this[_pending]. isEmpty)) {
840 this[_pending].schedule(this);
841 } else {
842 dart.assert(this[_mayResumeInput]);
843 this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_I NPUT_PAUSED);
844 if (!dart.notNull(this[_inCallback]))
845 this[_guardCallback](this[_onResume]);
846 }
847 }
848 }
849 }
850 cancel() {
851 this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_WAIT_FO R_CANCEL);
852 if (this[_isCanceled])
853 return this[_cancelFuture];
854 this[_cancel]();
855 return this[_cancelFuture];
856 }
857 asFuture(futureValue) {
858 if (futureValue === void 0)
859 futureValue = null;
860 let result = new _Future();
861 this[_onDone] = (() => {
862 result._complete(futureValue);
863 }).bind(this);
864 this[_onError] = ((error, stackTrace) => {
865 this.cancel();
866 result._completeError(error, dart.as(stackTrace, core.StackTrace));
867 }).bind(this);
868 return result;
869 }
870 get [_isInputPaused]() {
871 return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscr iption._STATE_INPUT_PAUSED)) !== 0;
872 }
873 get [_isClosed]() {
874 return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscr iption._STATE_CLOSED)) !== 0;
875 }
876 get [_isCanceled]() {
877 return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscr iption._STATE_CANCELED)) !== 0;
878 }
879 get [_waitsForCancel]() {
880 return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscr iption._STATE_WAIT_FOR_CANCEL)) !== 0;
881 }
882 get [_inCallback]() {
883 return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscr iption._STATE_IN_CALLBACK)) !== 0;
884 }
885 get [_hasPending]() {
886 return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscr iption._STATE_HAS_PENDING)) !== 0;
887 }
888 get [_isPaused]() {
889 return dart.notNull(this[_state]) >= dart.notNull(_BufferingStreamSubscr iption._STATE_PAUSE_COUNT);
890 }
891 get [_canFire]() {
892 return dart.notNull(this[_state]) < dart.notNull(_BufferingStreamSubscri ption._STATE_IN_CALLBACK);
893 }
894 get [_mayResumeInput]() {
895 return !dart.notNull(this[_isPaused]) && (dart.notNull(this[_pending] == = null) || dart.notNull(this[_pending].isEmpty));
896 }
897 get [_cancelOnError]() {
898 return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscr iption._STATE_CANCEL_ON_ERROR)) !== 0;
899 }
900 get isPaused() {
901 return this[_isPaused];
902 }
903 [_cancel]() {
904 this[_state] = _BufferingStreamSubscription._STATE_CANCELED;
905 if (this[_hasPending]) {
906 this[_pending].cancelSchedule();
907 }
908 if (!dart.notNull(this[_inCallback]))
909 this[_pending] = null;
910 this[_cancelFuture] = this[_onCancel]();
911 }
912 [_incrementPauseCount]() {
913 this[_state] = dart.notNull(this[_state]) + dart.notNull(_BufferingStrea mSubscription._STATE_PAUSE_COUNT) | dart.notNull(_BufferingStreamSubscription._S TATE_INPUT_PAUSED);
914 }
915 [_decrementPauseCount]() {
916 dart.assert(this[_isPaused]);
917 this[_state] = _BufferingStreamSubscription._STATE_PAUSE_COUNT;
918 }
919 [_add](data) {
920 dart.assert(!dart.notNull(this[_isClosed]));
921 if (this[_isCanceled])
922 return;
923 if (this[_canFire]) {
924 this[_sendData](data);
925 } else {
926 this[_addPending](new _DelayedData(data));
927 }
928 }
929 [_addError](error, stackTrace) {
930 if (this[_isCanceled])
931 return;
932 if (this[_canFire]) {
933 this[_sendError](error, stackTrace);
934 } else {
935 this[_addPending](new _DelayedError(error, stackTrace));
936 }
937 }
938 [_close]() {
939 dart.assert(!dart.notNull(this[_isClosed]));
940 if (this[_isCanceled])
941 return;
942 this[_state] = _BufferingStreamSubscription._STATE_CLOSED;
943 if (this[_canFire]) {
944 this[_sendDone]();
945 } else {
946 this[_addPending](new _DelayedDone());
947 }
948 }
949 [_onPause]() {
950 dart.assert(this[_isInputPaused]);
951 }
952 [_onResume]() {
953 dart.assert(!dart.notNull(this[_isInputPaused]));
954 }
955 [_onCancel]() {
956 dart.assert(this[_isCanceled]);
957 return null;
958 }
959 [_addPending](event) {
960 let pending = dart.as(this[_pending], _StreamImplEvents);
961 if (this[_pending] === null)
962 pending = this[_pending] = new _StreamImplEvents();
963 pending.add(event);
964 if (!dart.notNull(this[_hasPending])) {
965 this[_state] = _BufferingStreamSubscription._STATE_HAS_PENDING;
966 if (!dart.notNull(this[_isPaused])) {
967 this[_pending].schedule(this);
968 }
969 }
970 }
971 [_sendData](data) {
972 dart.assert(!dart.notNull(this[_isCanceled]));
973 dart.assert(!dart.notNull(this[_isPaused]));
974 dart.assert(!dart.notNull(this[_inCallback]));
975 let wasInputPaused = this[_isInputPaused];
976 this[_state] = _BufferingStreamSubscription._STATE_IN_CALLBACK;
977 this[_zone].runUnaryGuarded(this[_onData], data);
978 this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_IN_CALL BACK);
979 this[_checkState](wasInputPaused);
980 }
981 [_sendError](error, stackTrace) {
982 dart.assert(!dart.notNull(this[_isCanceled]));
983 dart.assert(!dart.notNull(this[_isPaused]));
984 dart.assert(!dart.notNull(this[_inCallback]));
985 let wasInputPaused = this[_isInputPaused];
986 // Function sendError: () → void
987 function sendError() {
988 if (dart.notNull(this[_isCanceled]) && !dart.notNull(this[_waitsForCan cel]))
989 return;
990 this[_state] = _BufferingStreamSubscription._STATE_IN_CALLBACK;
991 if (dart.is(this[_onError], ZoneBinaryCallback)) {
992 this[_zone].runBinaryGuarded(dart.as(this[_onError], dart.throw_("Un implemented type (dynamic, dynamic) → dynamic")), error, stackTrace);
993 } else {
994 this[_zone].runUnaryGuarded(dart.as(this[_onError], dart.throw_("Uni mplemented type (dynamic) → dynamic")), error);
995 }
996 this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_IN_CA LLBACK);
997 }
998 if (this[_cancelOnError]) {
999 this[_state] = _BufferingStreamSubscription._STATE_WAIT_FOR_CANCEL;
1000 this[_cancel]();
1001 if (dart.is(this[_cancelFuture], Future)) {
1002 this[_cancelFuture].whenComplete(sendError);
1003 } else {
1004 sendError();
1005 }
1006 } else {
1007 sendError();
1008 this[_checkState](wasInputPaused);
1009 }
1010 }
1011 [_sendDone]() {
1012 dart.assert(!dart.notNull(this[_isCanceled]));
1013 dart.assert(!dart.notNull(this[_isPaused]));
1014 dart.assert(!dart.notNull(this[_inCallback]));
1015 // Function sendDone: () → void
1016 function sendDone() {
1017 if (!dart.notNull(this[_waitsForCancel]))
1018 return;
1019 this[_state] = dart.notNull(_BufferingStreamSubscription._STATE_CANCEL ED) | dart.notNull(_BufferingStreamSubscription._STATE_CLOSED) | dart.notNull(_B ufferingStreamSubscription._STATE_IN_CALLBACK);
1020 this[_zone].runGuarded(this[_onDone]);
1021 this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_IN_CA LLBACK);
1022 }
1023 this[_cancel]();
1024 this[_state] = _BufferingStreamSubscription._STATE_WAIT_FOR_CANCEL;
1025 if (dart.is(this[_cancelFuture], Future)) {
1026 this[_cancelFuture].whenComplete(sendDone);
1027 } else {
1028 sendDone();
1029 }
1030 }
1031 [_guardCallback](callback) {
1032 dart.assert(!dart.notNull(this[_inCallback]));
1033 let wasInputPaused = this[_isInputPaused];
1034 this[_state] = _BufferingStreamSubscription._STATE_IN_CALLBACK;
1035 dart.dinvokef(callback);
1036 this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_IN_CALL BACK);
1037 this[_checkState](wasInputPaused);
1038 }
1039 [_checkState](wasInputPaused) {
1040 dart.assert(!dart.notNull(this[_inCallback]));
1041 if (dart.notNull(this[_hasPending]) && dart.notNull(this[_pending].isEmp ty)) {
1042 this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_HAS_P ENDING);
1043 if (dart.notNull(this[_isInputPaused]) && dart.notNull(this[_mayResume Input])) {
1044 this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_INP UT_PAUSED);
1045 }
1046 }
1047 while (true) {
1048 if (this[_isCanceled]) {
1049 this[_pending] = null;
1050 return;
1051 }
1052 let isInputPaused = this[_isInputPaused];
1053 if (wasInputPaused === isInputPaused)
1054 break;
1055 this[_state] = _BufferingStreamSubscription._STATE_IN_CALLBACK;
1056 if (isInputPaused) {
1057 this[_onPause]();
1058 } else {
1059 this[_onResume]();
1060 }
1061 this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_IN_CA LLBACK);
1062 wasInputPaused = isInputPaused;
1063 }
1064 if (dart.notNull(this[_hasPending]) && !dart.notNull(this[_isPaused])) {
1065 this[_pending].schedule(this);
1066 }
1067 }
1068 }
1069 _BufferingStreamSubscription._STATE_CANCEL_ON_ERROR = 1;
1070 _BufferingStreamSubscription._STATE_CLOSED = 2;
1071 _BufferingStreamSubscription._STATE_INPUT_PAUSED = 4;
1072 _BufferingStreamSubscription._STATE_CANCELED = 8;
1073 _BufferingStreamSubscription._STATE_WAIT_FOR_CANCEL = 16;
1074 _BufferingStreamSubscription._STATE_IN_CALLBACK = 32;
1075 _BufferingStreamSubscription._STATE_HAS_PENDING = 64;
1076 _BufferingStreamSubscription._STATE_PAUSE_COUNT = 128;
1077 _BufferingStreamSubscription._STATE_PAUSE_COUNT_SHIFT = 7;
1078 return _BufferingStreamSubscription;
1079 });
1080 let _BufferingStreamSubscription = _BufferingStreamSubscription$(dart.dynamic) ;
1081 let _ControllerSubscription$ = dart.generic(function(T) {
1082 class _ControllerSubscription extends _BufferingStreamSubscription$(T) {
1083 _ControllerSubscription($_controller, onData, onError, onDone, cancelOnErr or) {
1084 this[_controller] = $_controller;
1085 super._BufferingStreamSubscription(onData, onError, onDone, cancelOnErro r);
1086 }
1087 [_onCancel]() {
1088 return this[_controller]._recordCancel(this);
1089 }
1090 [_onPause]() {
1091 this[_controller]._recordPause(this);
1092 }
1093 [_onResume]() {
1094 this[_controller]._recordResume(this);
1095 }
1096 }
1097 return _ControllerSubscription;
1098 });
1099 let _ControllerSubscription = _ControllerSubscription$(dart.dynamic);
1100 let _BroadcastSubscription$ = dart.generic(function(T) {
1101 class _BroadcastSubscription extends _ControllerSubscription$(T) {
1102 _BroadcastSubscription(controller, onData, onError, onDone, cancelOnError) {
1103 this[_eventState] = null;
1104 this[_next] = null;
1105 this[_previous] = null;
1106 super._ControllerSubscription(dart.as(controller, _StreamControllerLifec ycle$(T)), onData, onError, onDone, cancelOnError);
1107 this[_next] = this[_previous] = this;
1108 }
1109 get [_controller]() {
1110 return dart.as(super[_controller], _BroadcastStreamController);
1111 }
1112 [_expectsEvent](eventId) {
1113 return (dart.notNull(this[_eventState]) & dart.notNull(_BroadcastSubscri ption._STATE_EVENT_ID)) === eventId;
1114 }
1115 [_toggleEventId]() {
1116 this[_eventState] = _BroadcastSubscription._STATE_EVENT_ID;
1117 }
1118 get [_isFiring]() {
1119 return (dart.notNull(this[_eventState]) & dart.notNull(_BroadcastSubscri ption._STATE_FIRING)) !== 0;
1120 }
1121 [_setRemoveAfterFiring]() {
1122 dart.assert(this[_isFiring]);
1123 this[_eventState] = _BroadcastSubscription._STATE_REMOVE_AFTER_FIRING;
1124 }
1125 get [_removeAfterFiring]() {
1126 return (dart.notNull(this[_eventState]) & dart.notNull(_BroadcastSubscri ption._STATE_REMOVE_AFTER_FIRING)) !== 0;
1127 }
1128 [_onPause]() {}
1129 [_onResume]() {}
1130 }
1131 _BroadcastSubscription._STATE_EVENT_ID = 1;
1132 _BroadcastSubscription._STATE_FIRING = 2;
1133 _BroadcastSubscription._STATE_REMOVE_AFTER_FIRING = 4;
1134 return _BroadcastSubscription;
1135 });
1136 let _BroadcastSubscription = _BroadcastSubscription$(dart.dynamic);
1137 let _addStreamState = Symbol('_addStreamState');
1138 let _doneFuture = Symbol('_doneFuture');
1139 let _isEmpty = Symbol('_isEmpty');
1140 let _hasOneListener = Symbol('_hasOneListener');
1141 let _isAddingStream = Symbol('_isAddingStream');
1142 let _mayAddEvent = Symbol('_mayAddEvent');
1143 let _ensureDoneFuture = Symbol('_ensureDoneFuture');
1144 let _addListener = Symbol('_addListener');
1145 let _removeListener = Symbol('_removeListener');
1146 let _subscribe = Symbol('_subscribe');
1147 let _recordCancel = Symbol('_recordCancel');
1148 let _callOnCancel = Symbol('_callOnCancel');
1149 let _recordPause = Symbol('_recordPause');
1150 let _recordResume = Symbol('_recordResume');
1151 let _addEventError = Symbol('_addEventError');
1152 let _forEachListener = Symbol('_forEachListener');
1153 let _STATE_FIRING = Symbol('_STATE_FIRING');
1154 let _mayComplete = Symbol('_mayComplete');
1155 let _BroadcastStreamController$ = dart.generic(function(T) {
1156 class _BroadcastStreamController extends core.Object {
1157 _BroadcastStreamController($_onListen, $_onCancel) {
1158 this[_onListen] = $_onListen;
1159 this[_onCancel] = $_onCancel;
1160 this[_state] = _BroadcastStreamController._STATE_INITIAL;
1161 this[_next] = null;
1162 this[_previous] = null;
1163 this[_addStreamState] = null;
1164 this[_doneFuture] = null;
1165 this[_next] = this[_previous] = this;
1166 }
1167 get stream() {
1168 return new _BroadcastStream(this);
1169 }
1170 get sink() {
1171 return new _StreamSinkWrapper(this);
1172 }
1173 get isClosed() {
1174 return (dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamContro ller._STATE_CLOSED)) !== 0;
1175 }
1176 get isPaused() {
1177 return false;
1178 }
1179 get hasListener() {
1180 return !dart.notNull(this[_isEmpty]);
1181 }
1182 get [_hasOneListener]() {
1183 dart.assert(!dart.notNull(this[_isEmpty]));
1184 return core.identical(this[_next][_next], this);
1185 }
1186 get [_isFiring]() {
1187 return (dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamContro ller._STATE_FIRING)) !== 0;
1188 }
1189 get [_isAddingStream]() {
1190 return (dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamContro ller._STATE_ADDSTREAM)) !== 0;
1191 }
1192 get [_mayAddEvent]() {
1193 return dart.notNull(this[_state]) < dart.notNull(_BroadcastStreamControl ler._STATE_CLOSED);
1194 }
1195 [_ensureDoneFuture]() {
1196 if (this[_doneFuture] !== null)
1197 return this[_doneFuture];
1198 return this[_doneFuture] = new _Future();
1199 }
1200 get [_isEmpty]() {
1201 return core.identical(this[_next], this);
1202 }
1203 [_addListener](subscription) {
1204 dart.assert(core.identical(subscription[_next], subscription));
1205 subscription[_previous] = this[_previous];
1206 subscription[_next] = this;
1207 this[_previous][_next] = subscription;
1208 this[_previous] = subscription;
1209 subscription[_eventState] = dart.notNull(this[_state]) & dart.notNull(_B roadcastStreamController._STATE_EVENT_ID);
1210 }
1211 [_removeListener](subscription) {
1212 dart.assert(core.identical(subscription[_controller], this));
1213 dart.assert(!dart.notNull(core.identical(subscription[_next], subscripti on)));
1214 let previous = subscription[_previous];
1215 let next = subscription[_next];
1216 previous[_next] = next;
1217 next[_previous] = previous;
1218 subscription[_next] = subscription[_previous] = subscription;
1219 }
1220 [_subscribe](onData, onError, onDone, cancelOnError) {
1221 if (this.isClosed) {
1222 if (onDone === null)
1223 onDone = _nullDoneHandler;
1224 return new _DoneStreamSubscription(onDone);
1225 }
1226 let subscription = new _BroadcastSubscription(this, onData, onError, onD one, cancelOnError);
1227 this[_addListener](dart.as(subscription, _BroadcastSubscription$(T)));
1228 if (core.identical(this[_next], this[_previous])) {
1229 _runGuarded(this[_onListen]);
1230 }
1231 return dart.as(subscription, StreamSubscription$(T));
1232 }
1233 [_recordCancel](subscription) {
1234 if (core.identical(subscription[_next], subscription))
1235 return null;
1236 dart.assert(!dart.notNull(core.identical(subscription[_next], subscripti on)));
1237 if (subscription[_isFiring]) {
1238 subscription._setRemoveAfterFiring();
1239 } else {
1240 dart.assert(!dart.notNull(core.identical(subscription[_next], subscrip tion)));
1241 this[_removeListener](subscription);
1242 if (!dart.notNull(this[_isFiring]) && dart.notNull(this[_isEmpty])) {
1243 this[_callOnCancel]();
1244 }
1245 }
1246 return null;
1247 }
1248 [_recordPause](subscription) {}
1249 [_recordResume](subscription) {}
1250 [_addEventError]() {
1251 if (this.isClosed) {
1252 return new core.StateError("Cannot add new events after calling close" );
1253 }
1254 dart.assert(this[_isAddingStream]);
1255 return new core.StateError("Cannot add new events while doing an addStre am");
1256 }
1257 add(data) {
1258 if (!dart.notNull(this[_mayAddEvent]))
1259 throw this[_addEventError]();
1260 this[_sendData](data);
1261 }
1262 addError(error, stackTrace) {
1263 if (stackTrace === void 0)
1264 stackTrace = null;
1265 error = _nonNullError(error);
1266 if (!dart.notNull(this[_mayAddEvent]))
1267 throw this[_addEventError]();
1268 let replacement = Zone.current.errorCallback(error, stackTrace);
1269 if (replacement !== null) {
1270 error = _nonNullError(replacement.error);
1271 stackTrace = replacement.stackTrace;
1272 }
1273 this[_sendError](error, stackTrace);
1274 }
1275 close() {
1276 if (this.isClosed) {
1277 dart.assert(this[_doneFuture] !== null);
1278 return this[_doneFuture];
1279 }
1280 if (!dart.notNull(this[_mayAddEvent]))
1281 throw this[_addEventError]();
1282 this[_state] = _BroadcastStreamController._STATE_CLOSED;
1283 let doneFuture = this[_ensureDoneFuture]();
1284 this[_sendDone]();
1285 return doneFuture;
1286 }
1287 get done() {
1288 return this[_ensureDoneFuture]();
1289 }
1290 addStream(stream, opt$) {
1291 let cancelOnError = opt$.cancelOnError === void 0 ? true : opt$.cancelOn Error;
1292 if (!dart.notNull(this[_mayAddEvent]))
1293 throw this[_addEventError]();
1294 this[_state] = _BroadcastStreamController._STATE_ADDSTREAM;
1295 this[_addStreamState] = dart.as(new _AddStreamState(this, stream, cancel OnError), _AddStreamState$(T));
1296 return this[_addStreamState].addStreamFuture;
1297 }
1298 [_add](data) {
1299 this[_sendData](data);
1300 }
1301 [_addError](error, stackTrace) {
1302 this[_sendError](error, stackTrace);
1303 }
1304 [_close]() {
1305 dart.assert(this[_isAddingStream]);
1306 let addState = this[_addStreamState];
1307 this[_addStreamState] = null;
1308 this[_state] = ~dart.notNull(_BroadcastStreamController._STATE_ADDSTREAM );
1309 addState.complete();
1310 }
1311 [_forEachListener](action) {
1312 if (this[_isFiring]) {
1313 throw new core.StateError("Cannot fire new event. Controller is alread y firing an event");
1314 }
1315 if (this[_isEmpty])
1316 return;
1317 let id = dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamContr oller._STATE_EVENT_ID);
1318 this[_state] = dart.notNull(_BroadcastStreamController._STATE_EVENT_ID) | dart.notNull(_BroadcastStreamController._STATE_FIRING);
1319 let link = this[_next];
1320 while (!dart.notNull(core.identical(link, this))) {
1321 let subscription = dart.as(link, _BroadcastSubscription$(T));
1322 if (subscription._expectsEvent(id)) {
1323 subscription[_eventState] = _BroadcastSubscription[_STATE_FIRING];
1324 action(subscription);
1325 subscription._toggleEventId();
1326 link = subscription[_next];
1327 if (subscription[_removeAfterFiring]) {
1328 this[_removeListener](subscription);
1329 }
1330 subscription[_eventState] = ~dart.notNull(_BroadcastSubscription[_ST ATE_FIRING]);
1331 } else {
1332 link = subscription[_next];
1333 }
1334 }
1335 this[_state] = ~dart.notNull(_BroadcastStreamController._STATE_FIRING);
1336 if (this[_isEmpty]) {
1337 this[_callOnCancel]();
1338 }
1339 }
1340 [_callOnCancel]() {
1341 dart.assert(this[_isEmpty]);
1342 if (dart.notNull(this.isClosed) && dart.notNull(this[_doneFuture][_mayCo mplete])) {
1343 this[_doneFuture]._asyncComplete(null);
1344 }
1345 _runGuarded(this[_onCancel]);
1346 }
1347 }
1348 _BroadcastStreamController._STATE_INITIAL = 0;
1349 _BroadcastStreamController._STATE_EVENT_ID = 1;
1350 _BroadcastStreamController._STATE_FIRING = 2;
1351 _BroadcastStreamController._STATE_CLOSED = 4;
1352 _BroadcastStreamController._STATE_ADDSTREAM = 8;
1353 return _BroadcastStreamController;
1354 });
1355 let _BroadcastStreamController = _BroadcastStreamController$(dart.dynamic);
1356 let _SyncBroadcastStreamController$ = dart.generic(function(T) {
1357 class _SyncBroadcastStreamController extends _BroadcastStreamController$(T) {
1358 _SyncBroadcastStreamController(onListen, onCancel) {
1359 super._BroadcastStreamController(onListen, onCancel);
1360 }
1361 [_sendData](data) {
1362 if (this[_isEmpty])
1363 return;
1364 if (this[_hasOneListener]) {
1365 this[_state] = _BroadcastStreamController[_STATE_FIRING];
1366 let subscription = dart.as(this[_next], _BroadcastSubscription);
1367 subscription._add(data);
1368 this[_state] = ~dart.notNull(_BroadcastStreamController[_STATE_FIRING] );
1369 if (this[_isEmpty]) {
1370 this[_callOnCancel]();
1371 }
1372 return;
1373 }
1374 this[_forEachListener](((subscription) => {
1375 subscription._add(data);
1376 }).bind(this));
1377 }
1378 [_sendError](error, stackTrace) {
1379 if (this[_isEmpty])
1380 return;
1381 this[_forEachListener](((subscription) => {
1382 subscription._addError(error, stackTrace);
1383 }).bind(this));
1384 }
1385 [_sendDone]() {
1386 if (!dart.notNull(this[_isEmpty])) {
1387 this[_forEachListener](dart.closureWrap(((subscription) => {
1388 subscription._close();
1389 }).bind(this), "(_BufferingStreamSubscription<T>) → void"));
1390 } else {
1391 dart.assert(this[_doneFuture] !== null);
1392 dart.assert(this[_doneFuture][_mayComplete]);
1393 this[_doneFuture]._asyncComplete(null);
1394 }
1395 }
1396 }
1397 return _SyncBroadcastStreamController;
1398 });
1399 let _SyncBroadcastStreamController = _SyncBroadcastStreamController$(dart.dyna mic);
1400 let _AsyncBroadcastStreamController$ = dart.generic(function(T) {
1401 class _AsyncBroadcastStreamController extends _BroadcastStreamController$(T) {
1402 _AsyncBroadcastStreamController(onListen, onCancel) {
1403 super._BroadcastStreamController(onListen, onCancel);
1404 }
1405 [_sendData](data) {
1406 for (let link = this[_next]; !dart.notNull(core.identical(link, this)); link = link[_next]) {
1407 let subscription = dart.as(link, _BroadcastSubscription$(T));
1408 subscription._addPending(new _DelayedData(data));
1409 }
1410 }
1411 [_sendError](error, stackTrace) {
1412 for (let link = this[_next]; !dart.notNull(core.identical(link, this)); link = link[_next]) {
1413 let subscription = dart.as(link, _BroadcastSubscription$(T));
1414 subscription._addPending(new _DelayedError(error, stackTrace));
1415 }
1416 }
1417 [_sendDone]() {
1418 if (!dart.notNull(this[_isEmpty])) {
1419 for (let link = this[_next]; !dart.notNull(core.identical(link, this)) ; link = link[_next]) {
1420 let subscription = dart.as(link, _BroadcastSubscription$(T));
1421 subscription._addPending(new _DelayedDone());
1422 }
1423 } else {
1424 dart.assert(this[_doneFuture] !== null);
1425 dart.assert(this[_doneFuture][_mayComplete]);
1426 this[_doneFuture]._asyncComplete(null);
1427 }
1428 }
1429 }
1430 return _AsyncBroadcastStreamController;
1431 });
1432 let _AsyncBroadcastStreamController = _AsyncBroadcastStreamController$(dart.dy namic);
1433 let _addPendingEvent = Symbol('_addPendingEvent');
1434 let _STATE_CLOSED = Symbol('_STATE_CLOSED');
1435 let _AsBroadcastStreamController$ = dart.generic(function(T) {
1436 class _AsBroadcastStreamController extends _SyncBroadcastStreamController$(T ) {
1437 _AsBroadcastStreamController(onListen, onCancel) {
1438 this[_pending] = null;
1439 super._SyncBroadcastStreamController(onListen, onCancel);
1440 }
1441 get [_hasPending]() {
1442 return dart.notNull(this[_pending] !== null) && !dart.notNull(this[_pend ing].isEmpty);
1443 }
1444 [_addPendingEvent](event) {
1445 if (this[_pending] === null) {
1446 this[_pending] = new _StreamImplEvents();
1447 }
1448 this[_pending].add(event);
1449 }
1450 add(data) {
1451 if (!dart.notNull(this.isClosed) && dart.notNull(this[_isFiring])) {
1452 this[_addPendingEvent](new _DelayedData(data));
1453 return;
1454 }
1455 super.add(data);
1456 while (this[_hasPending]) {
1457 this[_pending].handleNext(this);
1458 }
1459 }
1460 addError(error, stackTrace) {
1461 if (stackTrace === void 0)
1462 stackTrace = null;
1463 if (!dart.notNull(this.isClosed) && dart.notNull(this[_isFiring])) {
1464 this[_addPendingEvent](new _DelayedError(error, stackTrace));
1465 return;
1466 }
1467 if (!dart.notNull(this[_mayAddEvent]))
1468 throw this[_addEventError]();
1469 this[_sendError](error, stackTrace);
1470 while (this[_hasPending]) {
1471 this[_pending].handleNext(this);
1472 }
1473 }
1474 close() {
1475 if (!dart.notNull(this.isClosed) && dart.notNull(this[_isFiring])) {
1476 this[_addPendingEvent](new _DelayedDone());
1477 this[_state] = _BroadcastStreamController[_STATE_CLOSED];
1478 return super.done;
1479 }
1480 let result = super.close();
1481 dart.assert(!dart.notNull(this[_hasPending]));
1482 return result;
1483 }
1484 [_callOnCancel]() {
1485 if (this[_hasPending]) {
1486 this[_pending].clear();
1487 this[_pending] = null;
1488 }
1489 super._callOnCancel();
1490 }
1491 }
1492 return _AsBroadcastStreamController;
1493 });
1494 let _AsBroadcastStreamController = _AsBroadcastStreamController$(dart.dynamic) ;
1495 let _pauseCount = Symbol('_pauseCount');
1496 let _resume = Symbol('_resume');
1497 let _DoneSubscription$ = dart.generic(function(T) {
1498 class _DoneSubscription extends core.Object {
1499 _DoneSubscription() {
1500 this[_pauseCount] = 0;
1501 }
1502 onData(handleData) {}
1503 onError(handleError) {}
1504 onDone(handleDone) {}
1505 pause(resumeSignal) {
1506 if (resumeSignal === void 0)
1507 resumeSignal = null;
1508 if (resumeSignal !== null)
1509 resumeSignal.then(this[_resume]);
1510 this[_pauseCount] = dart.notNull(this[_pauseCount]) + 1;
1511 }
1512 resume() {
1513 this[_resume](null);
1514 }
1515 [_resume](_) {
1516 if (dart.notNull(this[_pauseCount]) > 0)
1517 this[_pauseCount] = dart.notNull(this[_pauseCount]) - 1;
1518 }
1519 cancel() {
1520 return new _Future.immediate(null);
1521 }
1522 get isPaused() {
1523 return dart.notNull(this[_pauseCount]) > 0;
1524 }
1525 asFuture(value) {
1526 if (value === void 0)
1527 value = null;
1528 return new _Future();
1529 }
1530 }
1531 return _DoneSubscription;
1532 });
1533 let _DoneSubscription = _DoneSubscription$(dart.dynamic);
1534 class DeferredLibrary extends core.Object {
1535 DeferredLibrary(libraryName, opt$) {
1536 let uri = opt$.uri === void 0 ? null : opt$.uri;
1537 this.libraryName = libraryName;
1538 this.uri = uri;
1539 }
1540 load() {
1541 throw 'DeferredLibrary not supported. ' + 'please use the `import "lib.dar t" deferred as lib` syntax.';
1542 }
1543 }
1544 let _s = Symbol('_s');
1545 class DeferredLoadException extends core.Object {
1546 DeferredLoadException($_s) {
1547 this[_s] = $_s;
1548 }
1549 toString() {
1550 return `DeferredLoadException: '${this[_s]}'`;
1551 }
1552 }
1553 let Future$ = dart.generic(function(T) {
1554 class Future extends core.Object {
1555 Future(computation) {
1556 let result = new _Future();
1557 Timer.run((() => {
1558 try {
1559 result._complete(computation());
1560 } catch (e) {
1561 let s = dart.stackTrace(e);
1562 _completeWithErrorCallback(result, e, s);
1563 }
1564
1565 }).bind(this));
1566 return dart.as(result, Future$(T));
1567 }
1568 Future$microtask(computation) {
1569 let result = new _Future();
1570 scheduleMicrotask((() => {
1571 try {
1572 result._complete(computation());
1573 } catch (e) {
1574 let s = dart.stackTrace(e);
1575 _completeWithErrorCallback(result, e, s);
1576 }
1577
1578 }).bind(this));
1579 return dart.as(result, Future$(T));
1580 }
1581 Future$sync(computation) {
1582 try {
1583 let result = computation();
1584 return new Future.value(result);
1585 } catch (error) {
1586 let stackTrace = dart.stackTrace(error);
1587 return new Future.error(error, stackTrace);
1588 }
1589
1590 }
1591 Future$value(value) {
1592 if (value === void 0)
1593 value = null;
1594 return new _Future.immediate(value);
1595 }
1596 Future$error(error, stackTrace) {
1597 if (stackTrace === void 0)
1598 stackTrace = null;
1599 error = _nonNullError(error);
1600 if (!dart.notNull(core.identical(Zone.current, _ROOT_ZONE))) {
1601 let replacement = Zone.current.errorCallback(error, stackTrace);
1602 if (replacement !== null) {
1603 error = _nonNullError(replacement.error);
1604 stackTrace = replacement.stackTrace;
1605 }
1606 }
1607 return new _Future.immediateError(error, stackTrace);
1608 }
1609 Future$delayed(duration, computation) {
1610 if (computation === void 0)
1611 computation = null;
1612 let result = new _Future();
1613 new Timer(duration, (() => {
1614 try {
1615 result._complete(computation === null ? null : computation());
1616 } catch (e) {
1617 let s = dart.stackTrace(e);
1618 _completeWithErrorCallback(result, e, s);
1619 }
1620
1621 }).bind(this));
1622 return dart.as(result, Future$(T));
1623 }
1624 static wait(futures, opt$) {
1625 let eagerError = opt$.eagerError === void 0 ? false : opt$.eagerError;
1626 let cleanUp = opt$.cleanUp === void 0 ? null : opt$.cleanUp;
1627 let result = new _Future();
1628 let values = null;
1629 let remaining = 0;
1630 let error = null;
1631 let stackTrace = null;
1632 // Function handleError: (dynamic, dynamic) → void
1633 function handleError(theError, theStackTrace) {
1634 remaining = dart.notNull(remaining) - 1;
1635 if (values !== null) {
1636 if (cleanUp !== null) {
1637 for (let value of values) {
1638 if (value !== null) {
1639 new Future.sync(() => {
1640 dart.dinvokef(cleanUp, value);
1641 });
1642 }
1643 }
1644 }
1645 values = null;
1646 if (remaining === 0 || dart.notNull(eagerError)) {
1647 result._completeError(theError, dart.as(theStackTrace, core.StackT race));
1648 } else {
1649 error = theError;
1650 stackTrace = dart.as(theStackTrace, core.StackTrace);
1651 }
1652 } else if (remaining === 0 && !dart.notNull(eagerError)) {
1653 result._completeError(error, stackTrace);
1654 }
1655 }
1656 for (let future of futures) {
1657 let pos = (($tmp) => remaining = dart.notNull($tmp) + 1, $tmp)(remaini ng);
1658 future.then(((value) => {
1659 remaining = dart.notNull(remaining) - 1;
1660 if (values !== null) {
1661 values.set(pos, value);
1662 if (remaining === 0) {
1663 result._completeWithValue(values);
1664 }
1665 } else {
1666 if (dart.notNull(cleanUp !== null) && dart.notNull(value !== null) ) {
1667 new Future.sync(() => {
1668 dart.dinvokef(cleanUp, value);
1669 });
1670 }
1671 if (remaining === 0 && !dart.notNull(eagerError)) {
1672 result._completeError(error, stackTrace);
1673 }
1674 }
1675 }).bind(this), {onError: handleError});
1676 }
1677 if (remaining === 0) {
1678 return dart.as(new Future.value(/* Unimplemented const */new List.from ([])), Future$(core.List));
1679 }
1680 values = new core.List(remaining);
1681 return result;
1682 }
1683 static forEach(input, f) {
1684 let iterator = input.iterator;
1685 return doWhile((() => {
1686 if (!dart.notNull(iterator.moveNext()))
1687 return false;
1688 return new Future.sync((() => dart.dinvokef(f, iterator.current)).bind (this)).then((_) => true);
1689 }).bind(this));
1690 }
1691 static doWhile(f) {
1692 let doneSignal = new _Future();
1693 let nextIteration = null;
1694 nextIteration = Zone.current.bindUnaryCallback(((keepGoing) => {
1695 if (keepGoing) {
1696 new Future.sync(f).then(dart.as(nextIteration, dart.throw_("Unimplem ented type (dynamic) → dynamic")), {onError: doneSignal[_completeError]});
1697 } else {
1698 doneSignal._complete(null);
1699 }
1700 }).bind(this), {runGuarded: true});
1701 dart.dinvokef(nextIteration, true);
1702 return doneSignal;
1703 }
1704 }
1705 dart.defineNamedConstructor(Future, 'microtask');
1706 dart.defineNamedConstructor(Future, 'sync');
1707 dart.defineNamedConstructor(Future, 'value');
1708 dart.defineNamedConstructor(Future, 'error');
1709 dart.defineNamedConstructor(Future, 'delayed');
1710 dart.defineLazyProperties(Future, {
1711 get _nullFuture() {
1712 return dart.as(new Future.value(null), _Future);
1713 }
1714 });
1715 return Future;
1716 });
1717 let Future = Future$(dart.dynamic);
1718 class TimeoutException extends core.Object {
1719 TimeoutException(message, duration) {
1720 if (duration === void 0)
1721 duration = null;
1722 this.message = message;
1723 this.duration = duration;
1724 }
1725 toString() {
1726 let result = "TimeoutException";
1727 if (this.duration !== null)
1728 result = `TimeoutException after ${this.duration}`;
1729 if (this.message !== null)
1730 result = `${result}: ${this.message}`;
1731 return result;
1732 }
1733 }
1734 let Completer$ = dart.generic(function(T) {
1735 class Completer extends core.Object {
1736 Completer() {
1737 return new _AsyncCompleter();
1738 }
1739 Completer$sync() {
1740 return new _SyncCompleter();
1741 }
1742 }
1743 dart.defineNamedConstructor(Completer, 'sync');
1744 return Completer;
1745 });
1746 let Completer = Completer$(dart.dynamic);
1747 // Function _completeWithErrorCallback: (_Future<dynamic>, dynamic, dynamic) → void
1748 function _completeWithErrorCallback(result, error, stackTrace) {
1749 let replacement = Zone.current.errorCallback(error, dart.as(stackTrace, core .StackTrace));
1750 if (replacement !== null) {
1751 error = _nonNullError(replacement.error);
1752 stackTrace = replacement.stackTrace;
1753 }
1754 result._completeError(error, dart.as(stackTrace, core.StackTrace));
1755 }
1756 // Function _nonNullError: (Object) → Object
1757 function _nonNullError(error) {
1758 return error !== null ? error : new core.NullThrownError();
1759 }
1760 let _Completer$ = dart.generic(function(T) {
1761 class _Completer extends core.Object {
1762 _Completer() {
1763 this.future = new _Future();
1764 }
1765 completeError(error, stackTrace) {
1766 if (stackTrace === void 0)
1767 stackTrace = null;
1768 error = _nonNullError(error);
1769 if (!dart.notNull(this.future[_mayComplete]))
1770 throw new core.StateError("Future already completed");
1771 let replacement = Zone.current.errorCallback(error, stackTrace);
1772 if (replacement !== null) {
1773 error = _nonNullError(replacement.error);
1774 stackTrace = replacement.stackTrace;
1775 }
1776 this[_completeError](error, stackTrace);
1777 }
1778 get isCompleted() {
1779 return !dart.notNull(this.future[_mayComplete]);
1780 }
1781 }
1782 return _Completer;
1783 });
1784 let _Completer = _Completer$(dart.dynamic);
1785 let _AsyncCompleter$ = dart.generic(function(T) {
1786 class _AsyncCompleter extends _Completer$(T) {
1787 complete(value) {
1788 if (value === void 0)
1789 value = null;
1790 if (!dart.notNull(this.future[_mayComplete]))
1791 throw new core.StateError("Future already completed");
1792 this.future._asyncComplete(value);
1793 }
1794 [_completeError](error, stackTrace) {
1795 this.future._asyncCompleteError(error, stackTrace);
1796 }
1797 }
1798 return _AsyncCompleter;
1799 });
1800 let _AsyncCompleter = _AsyncCompleter$(dart.dynamic);
1801 let _SyncCompleter$ = dart.generic(function(T) {
1802 class _SyncCompleter extends _Completer$(T) {
1803 complete(value) {
1804 if (value === void 0)
1805 value = null;
1806 if (!dart.notNull(this.future[_mayComplete]))
1807 throw new core.StateError("Future already completed");
1808 this.future._complete(value);
1809 }
1810 [_completeError](error, stackTrace) {
1811 this.future._completeError(error, stackTrace);
1812 }
1813 }
1814 return _SyncCompleter;
1815 });
1816 let _SyncCompleter = _SyncCompleter$(dart.dynamic);
1817 let _nextListener = Symbol('_nextListener');
1818 let _onValue = Symbol('_onValue');
1819 let _errorTest = Symbol('_errorTest');
1820 let _whenCompleteAction = Symbol('_whenCompleteAction');
1821 class _FutureListener extends core.Object {
1822 _FutureListener$then(result, onValue, errorCallback) {
1823 this.result = result;
1824 this.callback = onValue;
1825 this.errorCallback = errorCallback;
1826 this.state = errorCallback === null ? _FutureListener.STATE_THEN : _Future Listener.STATE_THEN_ONERROR;
1827 this[_nextListener] = null;
1828 }
1829 _FutureListener$catchError(result, errorCallback, test) {
1830 this.result = result;
1831 this.errorCallback = errorCallback;
1832 this.callback = test;
1833 this.state = test === null ? _FutureListener.STATE_CATCHERROR : _FutureLis tener.STATE_CATCHERROR_TEST;
1834 this[_nextListener] = null;
1835 }
1836 _FutureListener$whenComplete(result, onComplete) {
1837 this.result = result;
1838 this.callback = onComplete;
1839 this.errorCallback = null;
1840 this.state = _FutureListener.STATE_WHENCOMPLETE;
1841 this[_nextListener] = null;
1842 }
1843 _FutureListener$chain(result) {
1844 this.result = result;
1845 this.callback = null;
1846 this.errorCallback = null;
1847 this.state = _FutureListener.STATE_CHAIN;
1848 this[_nextListener] = null;
1849 }
1850 get [_zone]() {
1851 return this.result[_zone];
1852 }
1853 get handlesValue() {
1854 return (dart.notNull(this.state) & dart.notNull(_FutureListener.MASK_VALUE )) !== 0;
1855 }
1856 get handlesError() {
1857 return (dart.notNull(this.state) & dart.notNull(_FutureListener.MASK_ERROR )) !== 0;
1858 }
1859 get hasErrorTest() {
1860 return this.state === _FutureListener.STATE_CATCHERROR_TEST;
1861 }
1862 get handlesComplete() {
1863 return this.state === _FutureListener.STATE_WHENCOMPLETE;
1864 }
1865 get [_onValue]() {
1866 dart.assert(this.handlesValue);
1867 return dart.as(this.callback, _FutureOnValue);
1868 }
1869 get [_onError]() {
1870 return this.errorCallback;
1871 }
1872 get [_errorTest]() {
1873 dart.assert(this.hasErrorTest);
1874 return dart.as(this.callback, _FutureErrorTest);
1875 }
1876 get [_whenCompleteAction]() {
1877 dart.assert(this.handlesComplete);
1878 return dart.as(this.callback, _FutureAction);
1879 }
1880 }
1881 dart.defineNamedConstructor(_FutureListener, 'then');
1882 dart.defineNamedConstructor(_FutureListener, 'catchError');
1883 dart.defineNamedConstructor(_FutureListener, 'whenComplete');
1884 dart.defineNamedConstructor(_FutureListener, 'chain');
1885 _FutureListener.MASK_VALUE = 1;
1886 _FutureListener.MASK_ERROR = 2;
1887 _FutureListener.MASK_TEST_ERROR = 4;
1888 _FutureListener.MASK_WHENCOMPLETE = 8;
1889 _FutureListener.STATE_CHAIN = 0;
1890 _FutureListener.STATE_THEN = _FutureListener.MASK_VALUE;
1891 _FutureListener.STATE_THEN_ONERROR = dart.notNull(_FutureListener.MASK_VALUE) | dart.notNull(_FutureListener.MASK_ERROR);
1892 _FutureListener.STATE_CATCHERROR = _FutureListener.MASK_ERROR;
1893 _FutureListener.STATE_CATCHERROR_TEST = dart.notNull(_FutureListener.MASK_ERRO R) | dart.notNull(_FutureListener.MASK_TEST_ERROR);
1894 _FutureListener.STATE_WHENCOMPLETE = _FutureListener.MASK_WHENCOMPLETE;
1895 let _resultOrListeners = Symbol('_resultOrListeners');
1896 let _asyncComplete = Symbol('_asyncComplete');
1897 let _asyncCompleteError = Symbol('_asyncCompleteError');
1898 let _isChained = Symbol('_isChained');
1899 let _isComplete = Symbol('_isComplete');
1900 let _hasValue = Symbol('_hasValue');
1901 let _hasError = Symbol('_hasError');
1902 let _markPendingCompletion = Symbol('_markPendingCompletion');
1903 let _value = Symbol('_value');
1904 let _error = Symbol('_error');
1905 let _setValue = Symbol('_setValue');
1906 let _setErrorObject = Symbol('_setErrorObject');
1907 let _setError = Symbol('_setError');
1908 let _removeListeners = Symbol('_removeListeners');
1909 let _chainForeignFuture = Symbol('_chainForeignFuture');
1910 let _chainCoreFuture = Symbol('_chainCoreFuture');
1911 let _completeWithValue = Symbol('_completeWithValue');
1912 let _propagateToListeners = Symbol('_propagateToListeners');
1913 let _Future$ = dart.generic(function(T) {
1914 class _Future extends core.Object {
1915 _Future() {
1916 this[_zone] = Zone.current;
1917 this[_state] = _Future._INCOMPLETE;
1918 this[_resultOrListeners] = null;
1919 }
1920 _Future$immediate(value) {
1921 this[_zone] = Zone.current;
1922 this[_state] = _Future._INCOMPLETE;
1923 this[_resultOrListeners] = null;
1924 this[_asyncComplete](value);
1925 }
1926 _Future$immediateError(error, stackTrace) {
1927 if (stackTrace === void 0)
1928 stackTrace = null;
1929 this[_zone] = Zone.current;
1930 this[_state] = _Future._INCOMPLETE;
1931 this[_resultOrListeners] = null;
1932 this[_asyncCompleteError](error, stackTrace);
1933 }
1934 get [_mayComplete]() {
1935 return this[_state] === _Future._INCOMPLETE;
1936 }
1937 get [_isChained]() {
1938 return this[_state] === _Future._CHAINED;
1939 }
1940 get [_isComplete]() {
1941 return dart.notNull(this[_state]) >= dart.notNull(_Future._VALUE);
1942 }
1943 get [_hasValue]() {
1944 return this[_state] === _Future._VALUE;
1945 }
1946 get [_hasError]() {
1947 return this[_state] === _Future._ERROR;
1948 }
1949 set [_isChained](value) {
1950 if (value) {
1951 dart.assert(!dart.notNull(this[_isComplete]));
1952 this[_state] = _Future._CHAINED;
1953 } else {
1954 dart.assert(this[_isChained]);
1955 this[_state] = _Future._INCOMPLETE;
1956 }
1957 }
1958 then(f, opt$) {
1959 let onError = opt$.onError === void 0 ? null : opt$.onError;
1960 let result = new _Future();
1961 if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
1962 f = dart.closureWrap(result[_zone].registerUnaryCallback(f), "(T) → dy namic");
1963 if (onError !== null) {
1964 onError = _registerErrorHandler(onError, result[_zone]);
1965 }
1966 }
1967 this[_addListener](new _FutureListener.then(result, f, onError));
1968 return result;
1969 }
1970 catchError(onError, opt$) {
1971 let test = opt$.test === void 0 ? null : opt$.test;
1972 let result = new _Future();
1973 if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
1974 onError = _registerErrorHandler(onError, result[_zone]);
1975 if (test !== null)
1976 test = dart.closureWrap(result[_zone].registerUnaryCallback(test), " (dynamic) → bool");
1977 }
1978 this[_addListener](new _FutureListener.catchError(result, onError, test) );
1979 return result;
1980 }
1981 whenComplete(action) {
1982 let result = new _Future();
1983 if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
1984 action = result[_zone].registerCallback(action);
1985 }
1986 this[_addListener](new _FutureListener.whenComplete(result, action));
1987 return dart.as(result, Future$(T));
1988 }
1989 asStream() {
1990 return dart.as(new Stream.fromFuture(this), Stream$(T));
1991 }
1992 [_markPendingCompletion]() {
1993 if (!dart.notNull(this[_mayComplete]))
1994 throw new core.StateError("Future already completed");
1995 this[_state] = _Future._PENDING_COMPLETE;
1996 }
1997 get [_value]() {
1998 dart.assert(dart.notNull(this[_isComplete]) && dart.notNull(this[_hasVal ue]));
1999 return dart.as(this[_resultOrListeners], T);
2000 }
2001 get [_error]() {
2002 dart.assert(dart.notNull(this[_isComplete]) && dart.notNull(this[_hasErr or]));
2003 return dart.as(this[_resultOrListeners], AsyncError);
2004 }
2005 [_setValue](value) {
2006 dart.assert(!dart.notNull(this[_isComplete]));
2007 this[_state] = _Future._VALUE;
2008 this[_resultOrListeners] = value;
2009 }
2010 [_setErrorObject](error) {
2011 dart.assert(!dart.notNull(this[_isComplete]));
2012 this[_state] = _Future._ERROR;
2013 this[_resultOrListeners] = error;
2014 }
2015 [_setError](error, stackTrace) {
2016 this[_setErrorObject](new AsyncError(error, stackTrace));
2017 }
2018 [_addListener](listener) {
2019 dart.assert(listener[_nextListener] === null);
2020 if (this[_isComplete]) {
2021 this[_zone].scheduleMicrotask((() => {
2022 _propagateToListeners(this, listener);
2023 }).bind(this));
2024 } else {
2025 listener[_nextListener] = dart.as(this[_resultOrListeners], _FutureLis tener);
2026 this[_resultOrListeners] = listener;
2027 }
2028 }
2029 [_removeListeners]() {
2030 dart.assert(!dart.notNull(this[_isComplete]));
2031 let current = dart.as(this[_resultOrListeners], _FutureListener);
2032 this[_resultOrListeners] = null;
2033 let prev = null;
2034 while (current !== null) {
2035 let next = current[_nextListener];
2036 current[_nextListener] = prev;
2037 prev = current;
2038 current = next;
2039 }
2040 return prev;
2041 }
2042 static [_chainForeignFuture](source, target) {
2043 dart.assert(!dart.notNull(target[_isComplete]));
2044 dart.assert(!dart.is(source, _Future));
2045 target[_isChained] = true;
2046 source.then(((value) => {
2047 dart.assert(target[_isChained]);
2048 target._completeWithValue(value);
2049 }).bind(this), {onError: ((error, stackTrace) => {
2050 if (stackTrace === void 0)
2051 stackTrace = null;
2052 dart.assert(target[_isChained]);
2053 target._completeError(error, dart.as(stackTrace, core.StackTrace));
2054 }).bind(this)});
2055 }
2056 static [_chainCoreFuture](source, target) {
2057 dart.assert(!dart.notNull(target[_isComplete]));
2058 dart.assert(dart.is(source, _Future));
2059 target[_isChained] = true;
2060 let listener = new _FutureListener.chain(target);
2061 if (source[_isComplete]) {
2062 _propagateToListeners(source, listener);
2063 } else {
2064 source._addListener(listener);
2065 }
2066 }
2067 [_complete](value) {
2068 dart.assert(!dart.notNull(this[_isComplete]));
2069 if (dart.is(value, Future)) {
2070 if (dart.is(value, _Future)) {
2071 _chainCoreFuture(dart.as(value, _Future), this);
2072 } else {
2073 _chainForeignFuture(dart.as(value, Future), this);
2074 }
2075 } else {
2076 let listeners = this[_removeListeners]();
2077 this[_setValue](dart.as(value, T));
2078 _propagateToListeners(this, listeners);
2079 }
2080 }
2081 [_completeWithValue](value) {
2082 dart.assert(!dart.notNull(this[_isComplete]));
2083 dart.assert(!dart.is(value, Future));
2084 let listeners = this[_removeListeners]();
2085 this[_setValue](dart.as(value, T));
2086 _propagateToListeners(this, listeners);
2087 }
2088 [_completeError](error, stackTrace) {
2089 if (stackTrace === void 0)
2090 stackTrace = null;
2091 dart.assert(!dart.notNull(this[_isComplete]));
2092 let listeners = this[_removeListeners]();
2093 this[_setError](error, stackTrace);
2094 _propagateToListeners(this, listeners);
2095 }
2096 [_asyncComplete](value) {
2097 dart.assert(!dart.notNull(this[_isComplete]));
2098 if (value === null) {
2099 } else if (dart.is(value, Future)) {
2100 let typedFuture = dart.as(value, Future$(T));
2101 if (dart.is(typedFuture, _Future)) {
2102 let coreFuture = dart.as(typedFuture, _Future$(T));
2103 if (dart.notNull(coreFuture[_isComplete]) && dart.notNull(coreFuture [_hasError])) {
2104 this[_markPendingCompletion]();
2105 this[_zone].scheduleMicrotask((() => {
2106 _chainCoreFuture(coreFuture, this);
2107 }).bind(this));
2108 } else {
2109 _chainCoreFuture(coreFuture, this);
2110 }
2111 } else {
2112 _chainForeignFuture(typedFuture, this);
2113 }
2114 return;
2115 } else {
2116 let typedValue = dart.as(value, T);
2117 }
2118 this[_markPendingCompletion]();
2119 this[_zone].scheduleMicrotask((() => {
2120 this[_completeWithValue](value);
2121 }).bind(this));
2122 }
2123 [_asyncCompleteError](error, stackTrace) {
2124 dart.assert(!dart.notNull(this[_isComplete]));
2125 this[_markPendingCompletion]();
2126 this[_zone].scheduleMicrotask((() => {
2127 this[_completeError](error, stackTrace);
2128 }).bind(this));
2129 }
2130 static [_propagateToListeners](source, listeners) {
2131 while (true) {
2132 dart.assert(source[_isComplete]);
2133 let hasError = source[_hasError];
2134 if (listeners === null) {
2135 if (hasError) {
2136 let asyncError = source[_error];
2137 source[_zone].handleUncaughtError(asyncError.error, asyncError.sta ckTrace);
2138 }
2139 return;
2140 }
2141 while (listeners[_nextListener] !== null) {
2142 let listener = listeners;
2143 listeners = listener[_nextListener];
2144 listener[_nextListener] = null;
2145 _propagateToListeners(source, listener);
2146 }
2147 let listener = listeners;
2148 let listenerHasValue = true;
2149 let sourceValue = hasError ? null : source[_value];
2150 let listenerValueOrError = sourceValue;
2151 let isPropagationAborted = false;
2152 if (dart.notNull(hasError) || dart.notNull(listener.handlesValue) || d art.notNull(listener.handlesComplete)) {
2153 let zone = listener[_zone];
2154 if (dart.notNull(hasError) && !dart.notNull(source[_zone].inSameErro rZone(zone))) {
2155 let asyncError = source[_error];
2156 source[_zone].handleUncaughtError(asyncError.error, asyncError.sta ckTrace);
2157 return;
2158 }
2159 let oldZone = null;
2160 if (!dart.notNull(core.identical(Zone.current, zone))) {
2161 oldZone = Zone._enter(zone);
2162 }
2163 // Function handleValueCallback: () → bool
2164 function handleValueCallback() {
2165 try {
2166 listenerValueOrError = zone.runUnary(listener[_onValue], sourceV alue);
2167 return true;
2168 } catch (e) {
2169 let s = dart.stackTrace(e);
2170 listenerValueOrError = new AsyncError(e, s);
2171 return false;
2172 }
2173
2174 }
2175 // Function handleError: () → void
2176 function handleError() {
2177 let asyncError = source[_error];
2178 let matchesTest = true;
2179 if (listener.hasErrorTest) {
2180 let test = listener[_errorTest];
2181 try {
2182 matchesTest = dart.as(zone.runUnary(test, asyncError.error), c ore.bool);
2183 } catch (e) {
2184 let s = dart.stackTrace(e);
2185 listenerValueOrError = core.identical(asyncError.error, e) ? a syncError : new AsyncError(e, s);
2186 listenerHasValue = false;
2187 return;
2188 }
2189
2190 }
2191 let errorCallback = listener[_onError];
2192 if (dart.notNull(matchesTest) && dart.notNull(errorCallback !== nu ll)) {
2193 try {
2194 if (dart.is(errorCallback, ZoneBinaryCallback)) {
2195 listenerValueOrError = zone.runBinary(errorCallback, asyncEr ror.error, asyncError.stackTrace);
2196 } else {
2197 listenerValueOrError = zone.runUnary(dart.as(errorCallback, dart.throw_("Unimplemented type (dynamic) → dynamic")), asyncError.error);
2198 }
2199 } catch (e) {
2200 let s = dart.stackTrace(e);
2201 listenerValueOrError = core.identical(asyncError.error, e) ? a syncError : new AsyncError(e, s);
2202 listenerHasValue = false;
2203 return;
2204 }
2205
2206 listenerHasValue = true;
2207 } else {
2208 listenerValueOrError = asyncError;
2209 listenerHasValue = false;
2210 }
2211 }
2212 // Function handleWhenCompleteCallback: () → void
2213 function handleWhenCompleteCallback() {
2214 let completeResult = null;
2215 try {
2216 completeResult = zone.run(listener[_whenCompleteAction]);
2217 } catch (e) {
2218 let s = dart.stackTrace(e);
2219 if (dart.notNull(hasError) && dart.notNull(core.identical(source [_error].error, e))) {
2220 listenerValueOrError = source[_error];
2221 } else {
2222 listenerValueOrError = new AsyncError(e, s);
2223 }
2224 listenerHasValue = false;
2225 return;
2226 }
2227
2228 if (dart.is(completeResult, Future)) {
2229 let result = listener.result;
2230 result[_isChained] = true;
2231 isPropagationAborted = true;
2232 dart.dinvoke(completeResult, 'then', (ignored) => {
2233 _propagateToListeners(source, new _FutureListener.chain(result ));
2234 }, {
2235 onError: (error, stackTrace) => {
2236 if (stackTrace === void 0)
2237 stackTrace = null;
2238 if (!dart.is(completeResult, _Future)) {
2239 completeResult = new _Future();
2240 dart.dinvoke(completeResult, '_setError', error, stackTrac e);
2241 }
2242 _propagateToListeners(dart.as(completeResult, _Future), new _FutureListener.chain(result));
2243 }
2244 });
2245 }
2246 }
2247 if (!dart.notNull(hasError)) {
2248 if (listener.handlesValue) {
2249 listenerHasValue = handleValueCallback();
2250 }
2251 } else {
2252 handleError();
2253 }
2254 if (listener.handlesComplete) {
2255 handleWhenCompleteCallback();
2256 }
2257 if (oldZone !== null)
2258 Zone._leave(oldZone);
2259 if (isPropagationAborted)
2260 return;
2261 if (dart.notNull(listenerHasValue) && !dart.notNull(core.identical(s ourceValue, listenerValueOrError)) && dart.notNull(dart.is(listenerValueOrError, Future))) {
2262 let chainSource = dart.as(listenerValueOrError, Future);
2263 let result = listener.result;
2264 if (dart.is(chainSource, _Future)) {
2265 if (chainSource[_isComplete]) {
2266 result[_isChained] = true;
2267 source = chainSource;
2268 listeners = new _FutureListener.chain(result);
2269 continue;
2270 } else {
2271 _chainCoreFuture(chainSource, result);
2272 }
2273 } else {
2274 _chainForeignFuture(chainSource, result);
2275 }
2276 return;
2277 }
2278 }
2279 let result = listener.result;
2280 listeners = result._removeListeners();
2281 if (listenerHasValue) {
2282 result._setValue(listenerValueOrError);
2283 } else {
2284 let asyncError = dart.as(listenerValueOrError, AsyncError);
2285 result._setErrorObject(asyncError);
2286 }
2287 source = result;
2288 }
2289 }
2290 timeout(timeLimit, opt$) {
2291 let onTimeout = opt$.onTimeout === void 0 ? null : opt$.onTimeout;
2292 if (this[_isComplete])
2293 return new _Future.immediate(this);
2294 let result = new _Future();
2295 let timer = null;
2296 if (onTimeout === null) {
2297 timer = new Timer(timeLimit, (() => {
2298 result._completeError(new TimeoutException("Future not completed", t imeLimit));
2299 }).bind(this));
2300 } else {
2301 let zone = Zone.current;
2302 onTimeout = zone.registerCallback(onTimeout);
2303 timer = new Timer(timeLimit, (() => {
2304 try {
2305 result._complete(zone.run(onTimeout));
2306 } catch (e) {
2307 let s = dart.stackTrace(e);
2308 result._completeError(e, s);
2309 }
2310
2311 }).bind(this));
2312 }
2313 this.then(((v) => {
2314 if (timer.isActive) {
2315 timer.cancel();
2316 result._completeWithValue(v);
2317 }
2318 }).bind(this), {onError: ((e, s) => {
2319 if (timer.isActive) {
2320 timer.cancel();
2321 result._completeError(e, dart.as(s, core.StackTrace));
2322 }
2323 }).bind(this)});
2324 return result;
2325 }
2326 }
2327 dart.defineNamedConstructor(_Future, 'immediate');
2328 dart.defineNamedConstructor(_Future, 'immediateError');
2329 _Future._INCOMPLETE = 0;
2330 _Future._PENDING_COMPLETE = 1;
2331 _Future._CHAINED = 2;
2332 _Future._VALUE = 4;
2333 _Future._ERROR = 8;
2334 return _Future;
2335 });
2336 let _Future = _Future$(dart.dynamic);
2337 class _AsyncCallbackEntry extends core.Object {
2338 _AsyncCallbackEntry(callback) {
2339 this.callback = callback;
2340 this.next = null;
2341 }
2342 }
2343 exports._nextCallback = null;
2344 exports._lastCallback = null;
2345 exports._lastPriorityCallback = null;
2346 exports._isInCallbackLoop = false;
2347 // Function _asyncRunCallbackLoop: () → void
2348 function _asyncRunCallbackLoop() {
2349 while (exports._nextCallback !== null) {
2350 exports._lastPriorityCallback = null;
2351 let entry = exports._nextCallback;
2352 exports._nextCallback = entry.next;
2353 if (exports._nextCallback === null)
2354 exports._lastCallback = null;
2355 entry.callback();
2356 }
2357 }
2358 // Function _asyncRunCallback: () → void
2359 function _asyncRunCallback() {
2360 exports._isInCallbackLoop = true;
2361 try {
2362 _asyncRunCallbackLoop();
2363 } finally {
2364 exports._lastPriorityCallback = null;
2365 exports._isInCallbackLoop = false;
2366 if (exports._nextCallback !== null)
2367 _AsyncRun._scheduleImmediate(_asyncRunCallback);
2368 }
2369 }
2370 // Function _scheduleAsyncCallback: (dynamic) → void
2371 function _scheduleAsyncCallback(callback) {
2372 if (exports._nextCallback === null) {
2373 exports._nextCallback = exports._lastCallback = new _AsyncCallbackEntry(da rt.as(callback, _AsyncCallback));
2374 if (!dart.notNull(exports._isInCallbackLoop)) {
2375 _AsyncRun._scheduleImmediate(_asyncRunCallback);
2376 }
2377 } else {
2378 let newEntry = new _AsyncCallbackEntry(dart.as(callback, _AsyncCallback));
2379 exports._lastCallback.next = newEntry;
2380 exports._lastCallback = newEntry;
2381 }
2382 }
2383 // Function _schedulePriorityAsyncCallback: (dynamic) → void
2384 function _schedulePriorityAsyncCallback(callback) {
2385 let entry = new _AsyncCallbackEntry(dart.as(callback, _AsyncCallback));
2386 if (exports._nextCallback === null) {
2387 _scheduleAsyncCallback(callback);
2388 exports._lastPriorityCallback = exports._lastCallback;
2389 } else if (exports._lastPriorityCallback === null) {
2390 entry.next = exports._nextCallback;
2391 exports._nextCallback = exports._lastPriorityCallback = entry;
2392 } else {
2393 entry.next = exports._lastPriorityCallback.next;
2394 exports._lastPriorityCallback.next = entry;
2395 exports._lastPriorityCallback = entry;
2396 if (entry.next === null) {
2397 exports._lastCallback = entry;
2398 }
2399 }
2400 }
2401 // Function scheduleMicrotask: (() → void) → void
2402 function scheduleMicrotask(callback) {
2403 if (core.identical(_ROOT_ZONE, Zone.current)) {
2404 _rootScheduleMicrotask(null, null, _ROOT_ZONE, callback);
2405 return;
2406 }
2407 Zone.current.scheduleMicrotask(Zone.current.bindCallback(callback, {runGuard ed: true}));
2408 }
2409 let _scheduleImmediate = Symbol('_scheduleImmediate');
2410 let _initializeScheduleImmediate = Symbol('_initializeScheduleImmediate');
2411 let _scheduleImmediateJsOverride = Symbol('_scheduleImmediateJsOverride');
2412 let _scheduleImmediateWithSetImmediate = Symbol('_scheduleImmediateWithSetImme diate');
2413 let _scheduleImmediateWithTimer = Symbol('_scheduleImmediateWithTimer');
2414 class _AsyncRun extends core.Object {
2415 static [_scheduleImmediate](callback) {
2416 dart.dinvokef(scheduleImmediateClosure, callback);
2417 }
2418 static [_initializeScheduleImmediate]() {
2419 _js_helper.requiresPreamble();
2420 if (self.scheduleImmediate !== null) {
2421 return _scheduleImmediateJsOverride;
2422 }
2423 if (dart.notNull(self.MutationObserver !== null) && dart.notNull(self.docu ment !== null)) {
2424 let div = self.document.createElement("div");
2425 let span = self.document.createElement("span");
2426 let storedCallback = null;
2427 // Function internalCallback: (dynamic) → dynamic
2428 function internalCallback(_) {
2429 _isolate_helper.leaveJsAsync();
2430 let f = storedCallback;
2431 storedCallback = null;
2432 dart.dinvokef(f);
2433 }
2434 ;
2435 let observer = new self.MutationObserver(_js_helper.convertDartClosureTo JS(internalCallback, 1));
2436 observer.observe(div, {childList: true});
2437 return (callback) => {
2438 dart.assert(storedCallback === null);
2439 _isolate_helper.enterJsAsync();
2440 storedCallback = callback;
2441 div.firstChild ? div.removeChild(span) : div.appendChild(span);
2442 };
2443 } else if (self.setImmediate !== null) {
2444 return _scheduleImmediateWithSetImmediate;
2445 }
2446 return _scheduleImmediateWithTimer;
2447 }
2448 static [_scheduleImmediateJsOverride](callback) {
2449 // Function internalCallback: () → dynamic
2450 function internalCallback() {
2451 _isolate_helper.leaveJsAsync();
2452 callback();
2453 }
2454 ;
2455 _isolate_helper.enterJsAsync();
2456 self.scheduleImmediate(_js_helper.convertDartClosureToJS(internalCallback, 0));
2457 }
2458 static [_scheduleImmediateWithSetImmediate](callback) {
2459 // Function internalCallback: () → dynamic
2460 function internalCallback() {
2461 _isolate_helper.leaveJsAsync();
2462 callback();
2463 }
2464 ;
2465 _isolate_helper.enterJsAsync();
2466 self.setImmediate(_js_helper.convertDartClosureToJS(internalCallback, 0));
2467 }
2468 static [_scheduleImmediateWithTimer](callback) {
2469 Timer._createTimer(core.Duration.ZERO, callback);
2470 }
2471 }
2472 dart.defineLazyProperties(_AsyncRun, {
2473 get scheduleImmediateClosure() {
2474 return _initializeScheduleImmediate();
2475 }
2476 });
2477 let StreamSubscription$ = dart.generic(function(T) {
2478 class StreamSubscription extends core.Object {
2479 }
2480 return StreamSubscription;
2481 });
2482 let StreamSubscription = StreamSubscription$(dart.dynamic);
2483 let EventSink$ = dart.generic(function(T) {
2484 class EventSink extends core.Object {
2485 }
2486 return EventSink;
2487 });
2488 let EventSink = EventSink$(dart.dynamic);
2489 let _stream = Symbol('_stream');
2490 let StreamView$ = dart.generic(function(T) {
2491 class StreamView extends Stream$(T) {
2492 StreamView($_stream) {
2493 this[_stream] = $_stream;
2494 super.Stream();
2495 }
2496 get isBroadcast() {
2497 return this[_stream].isBroadcast;
2498 }
2499 asBroadcastStream(opt$) {
2500 let onListen = opt$.onListen === void 0 ? null : opt$.onListen;
2501 let onCancel = opt$.onCancel === void 0 ? null : opt$.onCancel;
2502 return this[_stream].asBroadcastStream({onListen: onListen, onCancel: on Cancel});
2503 }
2504 listen(onData, opt$) {
2505 let onError = opt$.onError === void 0 ? null : opt$.onError;
2506 let onDone = opt$.onDone === void 0 ? null : opt$.onDone;
2507 let cancelOnError = opt$.cancelOnError === void 0 ? null : opt$.cancelOn Error;
2508 return this[_stream].listen(onData, {onError: onError, onDone: onDone, c ancelOnError: cancelOnError});
2509 }
2510 }
2511 return StreamView;
2512 });
2513 let StreamView = StreamView$(dart.dynamic);
2514 let StreamConsumer$ = dart.generic(function(S) {
2515 class StreamConsumer extends core.Object {
2516 }
2517 return StreamConsumer;
2518 });
2519 let StreamConsumer = StreamConsumer$(dart.dynamic);
2520 let StreamSink$ = dart.generic(function(S) {
2521 class StreamSink extends core.Object {
2522 }
2523 return StreamSink;
2524 });
2525 let StreamSink = StreamSink$(dart.dynamic);
2526 let StreamTransformer$ = dart.generic(function(S, T) {
2527 class StreamTransformer extends core.Object {
2528 StreamTransformer(transformer) {
2529 return new _StreamSubscriptionTransformer(transformer);
2530 }
2531 StreamTransformer$fromHandlers(opt$) {
2532 return new _StreamHandlerTransformer(opt$);
2533 }
2534 }
2535 dart.defineNamedConstructor(StreamTransformer, 'fromHandlers');
2536 return StreamTransformer;
2537 });
2538 let StreamTransformer = StreamTransformer$(dart.dynamic, dart.dynamic);
2539 let StreamIterator$ = dart.generic(function(T) {
2540 class StreamIterator extends core.Object {
2541 StreamIterator(stream) {
2542 return new _StreamIteratorImpl(stream);
2543 }
2544 }
2545 return StreamIterator;
2546 });
2547 let StreamIterator = StreamIterator$(dart.dynamic);
2548 let _ControllerEventSinkWrapper$ = dart.generic(function(T) {
2549 class _ControllerEventSinkWrapper extends core.Object {
2550 _ControllerEventSinkWrapper($_sink) {
2551 this[_sink] = $_sink;
2552 }
2553 add(data) {
2554 this[_sink].add(data);
2555 }
2556 addError(error, stackTrace) {
2557 if (stackTrace === void 0)
2558 stackTrace = null;
2559 this[_sink].addError(error, stackTrace);
2560 }
2561 close() {
2562 this[_sink].close();
2563 }
2564 }
2565 return _ControllerEventSinkWrapper;
2566 });
2567 let _ControllerEventSinkWrapper = _ControllerEventSinkWrapper$(dart.dynamic);
2568 let StreamController$ = dart.generic(function(T) {
2569 class StreamController extends core.Object {
2570 StreamController(opt$) {
2571 let onListen = opt$.onListen === void 0 ? null : opt$.onListen;
2572 let onPause = opt$.onPause === void 0 ? null : opt$.onPause;
2573 let onResume = opt$.onResume === void 0 ? null : opt$.onResume;
2574 let onCancel = opt$.onCancel === void 0 ? null : opt$.onCancel;
2575 let sync = opt$.sync === void 0 ? false : opt$.sync;
2576 if (dart.notNull(onListen === null) && dart.notNull(onPause === null) && dart.notNull(onResume === null) && dart.notNull(onCancel === null)) {
2577 return dart.as(sync ? new _NoCallbackSyncStreamController() : new _NoC allbackAsyncStreamController(), StreamController$(T));
2578 }
2579 return sync ? new _SyncStreamController(onListen, onPause, onResume, onC ancel) : new _AsyncStreamController(onListen, onPause, onResume, onCancel);
2580 }
2581 StreamController$broadcast(opt$) {
2582 let onListen = opt$.onListen === void 0 ? null : opt$.onListen;
2583 let onCancel = opt$.onCancel === void 0 ? null : opt$.onCancel;
2584 let sync = opt$.sync === void 0 ? false : opt$.sync;
2585 return sync ? new _SyncBroadcastStreamController(onListen, onCancel) : n ew _AsyncBroadcastStreamController(onListen, onCancel);
2586 }
2587 }
2588 dart.defineNamedConstructor(StreamController, 'broadcast');
2589 return StreamController;
2590 });
2591 let StreamController = StreamController$(dart.dynamic);
2592 let _StreamControllerLifecycle$ = dart.generic(function(T) {
2593 class _StreamControllerLifecycle extends core.Object {
2594 [_recordPause](subscription) {}
2595 [_recordResume](subscription) {}
2596 [_recordCancel](subscription) {
2597 return null;
2598 }
2599 }
2600 return _StreamControllerLifecycle;
2601 });
2602 let _StreamControllerLifecycle = _StreamControllerLifecycle$(dart.dynamic);
2603 let _varData = Symbol('_varData');
2604 let _isInitialState = Symbol('_isInitialState');
2605 let _subscription = Symbol('_subscription');
2606 let _pendingEvents = Symbol('_pendingEvents');
2607 let _ensurePendingEvents = Symbol('_ensurePendingEvents');
2608 let _badEventState = Symbol('_badEventState');
2609 let _nullFuture = Symbol('_nullFuture');
2610 let _closeUnchecked = Symbol('_closeUnchecked');
2611 let _StreamController$ = dart.generic(function(T) {
2612 class _StreamController extends core.Object {
2613 _StreamController() {
2614 this[_varData] = null;
2615 this[_state] = _StreamController._STATE_INITIAL;
2616 this[_doneFuture] = null;
2617 }
2618 get stream() {
2619 return dart.as(new _ControllerStream(this), Stream$(T));
2620 }
2621 get sink() {
2622 return new _StreamSinkWrapper(this);
2623 }
2624 get [_isCanceled]() {
2625 return (dart.notNull(this[_state]) & dart.notNull(_StreamController._STA TE_CANCELED)) !== 0;
2626 }
2627 get hasListener() {
2628 return (dart.notNull(this[_state]) & dart.notNull(_StreamController._STA TE_SUBSCRIBED)) !== 0;
2629 }
2630 get [_isInitialState]() {
2631 return (dart.notNull(this[_state]) & dart.notNull(_StreamController._STA TE_SUBSCRIPTION_MASK)) === _StreamController._STATE_INITIAL;
2632 }
2633 get isClosed() {
2634 return (dart.notNull(this[_state]) & dart.notNull(_StreamController._STA TE_CLOSED)) !== 0;
2635 }
2636 get isPaused() {
2637 return this.hasListener ? this[_subscription][_isInputPaused] : !dart.no tNull(this[_isCanceled]);
2638 }
2639 get [_isAddingStream]() {
2640 return (dart.notNull(this[_state]) & dart.notNull(_StreamController._STA TE_ADDSTREAM)) !== 0;
2641 }
2642 get [_mayAddEvent]() {
2643 return dart.notNull(this[_state]) < dart.notNull(_StreamController._STAT E_CLOSED);
2644 }
2645 get [_pendingEvents]() {
2646 dart.assert(this[_isInitialState]);
2647 if (!dart.notNull(this[_isAddingStream])) {
2648 return dart.as(this[_varData], _PendingEvents);
2649 }
2650 let state = dart.as(this[_varData], _StreamControllerAddStreamState);
2651 return dart.as(state.varData, _PendingEvents);
2652 }
2653 [_ensurePendingEvents]() {
2654 dart.assert(this[_isInitialState]);
2655 if (!dart.notNull(this[_isAddingStream])) {
2656 if (this[_varData] === null)
2657 this[_varData] = new _StreamImplEvents();
2658 return dart.as(this[_varData], _StreamImplEvents);
2659 }
2660 let state = dart.as(this[_varData], _StreamControllerAddStreamState);
2661 if (state.varData === null)
2662 state.varData = new _StreamImplEvents();
2663 return dart.as(state.varData, _StreamImplEvents);
2664 }
2665 get [_subscription]() {
2666 dart.assert(this.hasListener);
2667 if (this[_isAddingStream]) {
2668 let addState = dart.as(this[_varData], _StreamControllerAddStreamState );
2669 return dart.as(addState.varData, _ControllerSubscription);
2670 }
2671 return dart.as(this[_varData], _ControllerSubscription);
2672 }
2673 [_badEventState]() {
2674 if (this.isClosed) {
2675 return new core.StateError("Cannot add event after closing");
2676 }
2677 dart.assert(this[_isAddingStream]);
2678 return new core.StateError("Cannot add event while adding a stream");
2679 }
2680 addStream(source, opt$) {
2681 let cancelOnError = opt$.cancelOnError === void 0 ? true : opt$.cancelOn Error;
2682 if (!dart.notNull(this[_mayAddEvent]))
2683 throw this[_badEventState]();
2684 if (this[_isCanceled])
2685 return new _Future.immediate(null);
2686 let addState = new _StreamControllerAddStreamState(this, this[_varData], source, cancelOnError);
2687 this[_varData] = addState;
2688 this[_state] = _StreamController._STATE_ADDSTREAM;
2689 return addState.addStreamFuture;
2690 }
2691 get done() {
2692 return this[_ensureDoneFuture]();
2693 }
2694 [_ensureDoneFuture]() {
2695 if (this[_doneFuture] === null) {
2696 this[_doneFuture] = this[_isCanceled] ? Future[_nullFuture] : new _Fut ure();
2697 }
2698 return this[_doneFuture];
2699 }
2700 add(value) {
2701 if (!dart.notNull(this[_mayAddEvent]))
2702 throw this[_badEventState]();
2703 this[_add](value);
2704 }
2705 addError(error, stackTrace) {
2706 if (stackTrace === void 0)
2707 stackTrace = null;
2708 error = _nonNullError(error);
2709 if (!dart.notNull(this[_mayAddEvent]))
2710 throw this[_badEventState]();
2711 let replacement = Zone.current.errorCallback(error, stackTrace);
2712 if (replacement !== null) {
2713 error = _nonNullError(replacement.error);
2714 stackTrace = replacement.stackTrace;
2715 }
2716 this[_addError](error, stackTrace);
2717 }
2718 close() {
2719 if (this.isClosed) {
2720 return this[_ensureDoneFuture]();
2721 }
2722 if (!dart.notNull(this[_mayAddEvent]))
2723 throw this[_badEventState]();
2724 this[_closeUnchecked]();
2725 return this[_ensureDoneFuture]();
2726 }
2727 [_closeUnchecked]() {
2728 this[_state] = _StreamController._STATE_CLOSED;
2729 if (this.hasListener) {
2730 this[_sendDone]();
2731 } else if (this[_isInitialState]) {
2732 this[_ensurePendingEvents]().add(new _DelayedDone());
2733 }
2734 }
2735 [_add](value) {
2736 if (this.hasListener) {
2737 this[_sendData](value);
2738 } else if (this[_isInitialState]) {
2739 this[_ensurePendingEvents]().add(new _DelayedData(value));
2740 }
2741 }
2742 [_addError](error, stackTrace) {
2743 if (this.hasListener) {
2744 this[_sendError](error, stackTrace);
2745 } else if (this[_isInitialState]) {
2746 this[_ensurePendingEvents]().add(new _DelayedError(error, stackTrace)) ;
2747 }
2748 }
2749 [_close]() {
2750 dart.assert(this[_isAddingStream]);
2751 let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
2752 this[_varData] = addState.varData;
2753 this[_state] = ~dart.notNull(_StreamController._STATE_ADDSTREAM);
2754 addState.complete();
2755 }
2756 [_subscribe](onData, onError, onDone, cancelOnError) {
2757 if (!dart.notNull(this[_isInitialState])) {
2758 throw new core.StateError("Stream has already been listened to.");
2759 }
2760 let subscription = new _ControllerSubscription(this, onData, onError, on Done, cancelOnError);
2761 let pendingEvents = this[_pendingEvents];
2762 this[_state] = _StreamController._STATE_SUBSCRIBED;
2763 if (this[_isAddingStream]) {
2764 let addState = dart.as(this[_varData], _StreamControllerAddStreamState );
2765 addState.varData = subscription;
2766 addState.resume();
2767 } else {
2768 this[_varData] = subscription;
2769 }
2770 subscription._setPendingEvents(pendingEvents);
2771 subscription._guardCallback((() => {
2772 _runGuarded(this[_onListen]);
2773 }).bind(this));
2774 return dart.as(subscription, StreamSubscription$(T));
2775 }
2776 [_recordCancel](subscription) {
2777 let result = null;
2778 if (this[_isAddingStream]) {
2779 let addState = dart.as(this[_varData], _StreamControllerAddStreamState );
2780 result = addState.cancel();
2781 }
2782 this[_varData] = null;
2783 this[_state] = dart.notNull(this[_state]) & ~(dart.notNull(_StreamContro ller._STATE_SUBSCRIBED) | dart.notNull(_StreamController._STATE_ADDSTREAM)) | da rt.notNull(_StreamController._STATE_CANCELED);
2784 if (this[_onCancel] !== null) {
2785 if (result === null) {
2786 try {
2787 result = dart.as(this[_onCancel](), Future);
2788 } catch (e) {
2789 let s = dart.stackTrace(e);
2790 result = ((_) => {
2791 _._asyncCompleteError(e, s);
2792 return _;
2793 }).bind(this)(new _Future());
2794 }
2795
2796 } else {
2797 result = result.whenComplete(this[_onCancel]);
2798 }
2799 }
2800 // Function complete: () → void
2801 function complete() {
2802 if (dart.notNull(this[_doneFuture] !== null) && dart.notNull(this[_don eFuture][_mayComplete])) {
2803 this[_doneFuture]._asyncComplete(null);
2804 }
2805 }
2806 if (result !== null) {
2807 result = result.whenComplete(complete);
2808 } else {
2809 complete();
2810 }
2811 return result;
2812 }
2813 [_recordPause](subscription) {
2814 if (this[_isAddingStream]) {
2815 let addState = dart.as(this[_varData], _StreamControllerAddStreamState );
2816 addState.pause();
2817 }
2818 _runGuarded(this[_onPause]);
2819 }
2820 [_recordResume](subscription) {
2821 if (this[_isAddingStream]) {
2822 let addState = dart.as(this[_varData], _StreamControllerAddStreamState );
2823 addState.resume();
2824 }
2825 _runGuarded(this[_onResume]);
2826 }
2827 }
2828 _StreamController._STATE_INITIAL = 0;
2829 _StreamController._STATE_SUBSCRIBED = 1;
2830 _StreamController._STATE_CANCELED = 2;
2831 _StreamController._STATE_SUBSCRIPTION_MASK = 3;
2832 _StreamController._STATE_CLOSED = 4;
2833 _StreamController._STATE_ADDSTREAM = 8;
2834 return _StreamController;
2835 });
2836 let _StreamController = _StreamController$(dart.dynamic);
2837 let _SyncStreamControllerDispatch$ = dart.generic(function(T) {
2838 class _SyncStreamControllerDispatch extends core.Object {
2839 [_sendData](data) {
2840 this[_subscription]._add(data);
2841 }
2842 [_sendError](error, stackTrace) {
2843 this[_subscription]._addError(error, stackTrace);
2844 }
2845 [_sendDone]() {
2846 this[_subscription]._close();
2847 }
2848 }
2849 return _SyncStreamControllerDispatch;
2850 });
2851 let _SyncStreamControllerDispatch = _SyncStreamControllerDispatch$(dart.dynami c);
2852 let _AsyncStreamControllerDispatch$ = dart.generic(function(T) {
2853 class _AsyncStreamControllerDispatch extends core.Object {
2854 [_sendData](data) {
2855 this[_subscription]._addPending(new _DelayedData(data));
2856 }
2857 [_sendError](error, stackTrace) {
2858 this[_subscription]._addPending(new _DelayedError(error, stackTrace));
2859 }
2860 [_sendDone]() {
2861 this[_subscription]._addPending(new _DelayedDone());
2862 }
2863 }
2864 return _AsyncStreamControllerDispatch;
2865 });
2866 let _AsyncStreamControllerDispatch = _AsyncStreamControllerDispatch$(dart.dyna mic);
2867 let _AsyncStreamController$ = dart.generic(function(T) {
2868 class _AsyncStreamController extends dart.mixin(_StreamController$(T), _Asyn cStreamControllerDispatch$(T)) {
2869 _AsyncStreamController($_onListen, $_onPause, $_onResume, $_onCancel) {
2870 this[_onListen] = $_onListen;
2871 this[_onPause] = $_onPause;
2872 this[_onResume] = $_onResume;
2873 this[_onCancel] = $_onCancel;
2874 super._StreamController();
2875 }
2876 }
2877 return _AsyncStreamController;
2878 });
2879 let _AsyncStreamController = _AsyncStreamController$(dart.dynamic);
2880 let _SyncStreamController$ = dart.generic(function(T) {
2881 class _SyncStreamController extends dart.mixin(_StreamController$(T), _SyncS treamControllerDispatch$(T)) {
2882 _SyncStreamController($_onListen, $_onPause, $_onResume, $_onCancel) {
2883 this[_onListen] = $_onListen;
2884 this[_onPause] = $_onPause;
2885 this[_onResume] = $_onResume;
2886 this[_onCancel] = $_onCancel;
2887 super._StreamController();
2888 }
2889 }
2890 return _SyncStreamController;
2891 });
2892 let _SyncStreamController = _SyncStreamController$(dart.dynamic);
2893 class _NoCallbacks extends core.Object {
2894 get [_onListen]() {
2895 return null;
2896 }
2897 get [_onPause]() {
2898 return null;
2899 }
2900 get [_onResume]() {
2901 return null;
2902 }
2903 get [_onCancel]() {
2904 return null;
2905 }
2906 }
2907 class _NoCallbackAsyncStreamController extends dart.mixin(_AsyncStreamControll erDispatch, _NoCallbacks) {
2908 }
2909 class _NoCallbackSyncStreamController extends dart.mixin(_SyncStreamController Dispatch, _NoCallbacks) {
2910 }
2911 // Function _runGuarded: (() → dynamic) → Future<dynamic>
2912 function _runGuarded(notificationHandler) {
2913 if (notificationHandler === null)
2914 return null;
2915 try {
2916 let result = notificationHandler();
2917 if (dart.is(result, Future))
2918 return dart.as(result, Future);
2919 return null;
2920 } catch (e) {
2921 let s = dart.stackTrace(e);
2922 Zone.current.handleUncaughtError(e, s);
2923 }
2924
2925 }
2926 let _target = Symbol('_target');
2927 let _StreamSinkWrapper$ = dart.generic(function(T) {
2928 class _StreamSinkWrapper extends core.Object {
2929 _StreamSinkWrapper($_target) {
2930 this[_target] = $_target;
2931 }
2932 add(data) {
2933 this[_target].add(data);
2934 }
2935 addError(error, stackTrace) {
2936 if (stackTrace === void 0)
2937 stackTrace = null;
2938 this[_target].addError(error, stackTrace);
2939 }
2940 close() {
2941 return this[_target].close();
2942 }
2943 addStream(source, opt$) {
2944 let cancelOnError = opt$.cancelOnError === void 0 ? true : opt$.cancelOn Error;
2945 return this[_target].addStream(source, {cancelOnError: cancelOnError});
2946 }
2947 get done() {
2948 return this[_target].done;
2949 }
2950 }
2951 return _StreamSinkWrapper;
2952 });
2953 let _StreamSinkWrapper = _StreamSinkWrapper$(dart.dynamic);
2954 let _AddStreamState$ = dart.generic(function(T) {
2955 class _AddStreamState extends core.Object {
2956 _AddStreamState(controller, source, cancelOnError) {
2957 this.addStreamFuture = new _Future();
2958 this.addSubscription = source.listen(controller[_add], {onError: dart.as (cancelOnError ? makeErrorHandler(controller) : controller[_addError], core.Func tion), onDone: controller[_close], cancelOnError: cancelOnError});
2959 }
2960 static makeErrorHandler(controller) {
2961 return ((e, s) => {
2962 controller._addError(e, s);
2963 controller._close();
2964 }).bind(this);
2965 }
2966 pause() {
2967 this.addSubscription.pause();
2968 }
2969 resume() {
2970 this.addSubscription.resume();
2971 }
2972 cancel() {
2973 let cancel = this.addSubscription.cancel();
2974 if (cancel === null) {
2975 this.addStreamFuture._asyncComplete(null);
2976 return null;
2977 }
2978 return cancel.whenComplete((() => {
2979 this.addStreamFuture._asyncComplete(null);
2980 }).bind(this));
2981 }
2982 complete() {
2983 this.addStreamFuture._asyncComplete(null);
2984 }
2985 }
2986 return _AddStreamState;
2987 });
2988 let _AddStreamState = _AddStreamState$(dart.dynamic);
2989 let _StreamControllerAddStreamState$ = dart.generic(function(T) {
2990 class _StreamControllerAddStreamState extends _AddStreamState$(T) {
2991 _StreamControllerAddStreamState(controller, varData, source, cancelOnError ) {
2992 this.varData = varData;
2993 super._AddStreamState(dart.as(controller, _EventSink$(T)), source, cance lOnError);
2994 if (controller.isPaused) {
2995 this.addSubscription.pause();
2996 }
2997 }
2998 }
2999 return _StreamControllerAddStreamState;
3000 });
3001 let _StreamControllerAddStreamState = _StreamControllerAddStreamState$(dart.dy namic);
3002 let _EventSink$ = dart.generic(function(T) {
3003 class _EventSink extends core.Object {
3004 }
3005 return _EventSink;
3006 });
3007 let _EventSink = _EventSink$(dart.dynamic);
3008 let _EventDispatch$ = dart.generic(function(T) {
3009 class _EventDispatch extends core.Object {
3010 }
3011 return _EventDispatch;
3012 });
3013 let _EventDispatch = _EventDispatch$(dart.dynamic);
3014 let _isUsed = Symbol('_isUsed');
3015 let _GeneratedStreamImpl$ = dart.generic(function(T) {
3016 class _GeneratedStreamImpl extends _StreamImpl$(T) {
3017 _GeneratedStreamImpl($_pending) {
3018 this[_pending] = $_pending;
3019 this[_isUsed] = false;
3020 super._StreamImpl();
3021 }
3022 [_createSubscription](onData, onError, onDone, cancelOnError) {
3023 if (this[_isUsed])
3024 throw new core.StateError("Stream has already been listened to.");
3025 this[_isUsed] = true;
3026 return ((_) => {
3027 _._setPendingEvents(this[_pending]());
3028 return _;
3029 }).bind(this)(new _BufferingStreamSubscription(onData, onError, onDone, cancelOnError));
3030 }
3031 }
3032 return _GeneratedStreamImpl;
3033 });
3034 let _GeneratedStreamImpl = _GeneratedStreamImpl$(dart.dynamic);
3035 let _iterator = Symbol('_iterator');
3036 let _eventScheduled = Symbol('_eventScheduled');
3037 class _PendingEvents extends core.Object {
3038 _PendingEvents() {
3039 this[_state] = _PendingEvents._STATE_UNSCHEDULED;
3040 }
3041 get isScheduled() {
3042 return this[_state] === _PendingEvents._STATE_SCHEDULED;
3043 }
3044 get [_eventScheduled]() {
3045 return dart.notNull(this[_state]) >= dart.notNull(_PendingEvents._STATE_SC HEDULED);
3046 }
3047 schedule(dispatch) {
3048 if (this.isScheduled)
3049 return;
3050 dart.assert(!dart.notNull(this.isEmpty));
3051 if (this[_eventScheduled]) {
3052 dart.assert(this[_state] === _PendingEvents._STATE_CANCELED);
3053 this[_state] = _PendingEvents._STATE_SCHEDULED;
3054 return;
3055 }
3056 scheduleMicrotask((() => {
3057 let oldState = this[_state];
3058 this[_state] = _PendingEvents._STATE_UNSCHEDULED;
3059 if (oldState === _PendingEvents._STATE_CANCELED)
3060 return;
3061 this.handleNext(dispatch);
3062 }).bind(this));
3063 this[_state] = _PendingEvents._STATE_SCHEDULED;
3064 }
3065 cancelSchedule() {
3066 if (this.isScheduled)
3067 this[_state] = _PendingEvents._STATE_CANCELED;
3068 }
3069 }
3070 _PendingEvents._STATE_UNSCHEDULED = 0;
3071 _PendingEvents._STATE_SCHEDULED = 1;
3072 _PendingEvents._STATE_CANCELED = 3;
3073 let _IterablePendingEvents$ = dart.generic(function(T) {
3074 class _IterablePendingEvents extends _PendingEvents {
3075 _IterablePendingEvents(data) {
3076 this[_iterator] = data.iterator;
3077 super._PendingEvents();
3078 }
3079 get isEmpty() {
3080 return this[_iterator] === null;
3081 }
3082 handleNext(dispatch) {
3083 if (this[_iterator] === null) {
3084 throw new core.StateError("No events pending.");
3085 }
3086 let isDone = null;
3087 try {
3088 isDone = !dart.notNull(this[_iterator].moveNext());
3089 } catch (e) {
3090 let s = dart.stackTrace(e);
3091 this[_iterator] = null;
3092 dispatch._sendError(e, s);
3093 return;
3094 }
3095
3096 if (!dart.notNull(isDone)) {
3097 dispatch._sendData(this[_iterator].current);
3098 } else {
3099 this[_iterator] = null;
3100 dispatch._sendDone();
3101 }
3102 }
3103 clear() {
3104 if (this.isScheduled)
3105 this.cancelSchedule();
3106 this[_iterator] = null;
3107 }
3108 }
3109 return _IterablePendingEvents;
3110 });
3111 let _IterablePendingEvents = _IterablePendingEvents$(dart.dynamic);
3112 // Function _nullDataHandler: (dynamic) → void
3113 function _nullDataHandler(value) {
3114 }
3115 // Function _nullErrorHandler: (dynamic, [StackTrace]) → void
3116 function _nullErrorHandler(error, stackTrace) {
3117 if (stackTrace === void 0)
3118 stackTrace = null;
3119 Zone.current.handleUncaughtError(error, stackTrace);
3120 }
3121 // Function _nullDoneHandler: () → void
3122 function _nullDoneHandler() {
3123 }
3124 class _DelayedEvent extends core.Object {
3125 _DelayedEvent() {
3126 this.next = null;
3127 }
3128 }
3129 let _DelayedData$ = dart.generic(function(T) {
3130 class _DelayedData extends _DelayedEvent {
3131 _DelayedData(value) {
3132 this.value = value;
3133 super._DelayedEvent();
3134 }
3135 perform(dispatch) {
3136 dispatch._sendData(this.value);
3137 }
3138 }
3139 return _DelayedData;
3140 });
3141 let _DelayedData = _DelayedData$(dart.dynamic);
3142 class _DelayedError extends _DelayedEvent {
3143 _DelayedError(error, stackTrace) {
3144 this.error = error;
3145 this.stackTrace = stackTrace;
3146 super._DelayedEvent();
3147 }
3148 perform(dispatch) {
3149 dispatch._sendError(this.error, this.stackTrace);
3150 }
3151 }
3152 class _DelayedDone extends core.Object {
3153 _DelayedDone() {
3154 }
3155 perform(dispatch) {
3156 dispatch._sendDone();
3157 }
3158 get next() {
3159 return null;
3160 }
3161 set next(_) {
3162 throw new core.StateError("No events after a done.");
3163 }
3164 }
3165 class _StreamImplEvents extends _PendingEvents {
3166 _StreamImplEvents() {
3167 this.firstPendingEvent = null;
3168 this.lastPendingEvent = null;
3169 super._PendingEvents();
3170 }
3171 get isEmpty() {
3172 return this.lastPendingEvent === null;
3173 }
3174 add(event) {
3175 if (this.lastPendingEvent === null) {
3176 this.firstPendingEvent = this.lastPendingEvent = event;
3177 } else {
3178 this.lastPendingEvent = this.lastPendingEvent.next = event;
3179 }
3180 }
3181 handleNext(dispatch) {
3182 dart.assert(!dart.notNull(this.isScheduled));
3183 let event = this.firstPendingEvent;
3184 this.firstPendingEvent = event.next;
3185 if (this.firstPendingEvent === null) {
3186 this.lastPendingEvent = null;
3187 }
3188 event.perform(dispatch);
3189 }
3190 clear() {
3191 if (this.isScheduled)
3192 this.cancelSchedule();
3193 this.firstPendingEvent = this.lastPendingEvent = null;
3194 }
3195 }
3196 let _unlink = Symbol('_unlink');
3197 let _insertBefore = Symbol('_insertBefore');
3198 class _BroadcastLinkedList extends core.Object {
3199 _BroadcastLinkedList() {
3200 this[_next] = null;
3201 this[_previous] = null;
3202 }
3203 [_unlink]() {
3204 this[_previous][_next] = this[_next];
3205 this[_next][_previous] = this[_previous];
3206 this[_next] = this[_previous] = this;
3207 }
3208 [_insertBefore](newNext) {
3209 let newPrevious = newNext[_previous];
3210 newPrevious[_next] = this;
3211 newNext[_previous] = this[_previous];
3212 this[_previous][_next] = newNext;
3213 this[_previous] = newPrevious;
3214 }
3215 }
3216 let _schedule = Symbol('_schedule');
3217 let _isSent = Symbol('_isSent');
3218 let _isScheduled = Symbol('_isScheduled');
3219 let _DoneStreamSubscription$ = dart.generic(function(T) {
3220 class _DoneStreamSubscription extends core.Object {
3221 _DoneStreamSubscription($_onDone) {
3222 this[_onDone] = $_onDone;
3223 this[_zone] = Zone.current;
3224 this[_state] = 0;
3225 this[_schedule]();
3226 }
3227 get [_isSent]() {
3228 return (dart.notNull(this[_state]) & dart.notNull(_DoneStreamSubscriptio n._DONE_SENT)) !== 0;
3229 }
3230 get [_isScheduled]() {
3231 return (dart.notNull(this[_state]) & dart.notNull(_DoneStreamSubscriptio n._SCHEDULED)) !== 0;
3232 }
3233 get isPaused() {
3234 return dart.notNull(this[_state]) >= dart.notNull(_DoneStreamSubscriptio n._PAUSED);
3235 }
3236 [_schedule]() {
3237 if (this[_isScheduled])
3238 return;
3239 this[_zone].scheduleMicrotask(this[_sendDone]);
3240 this[_state] = _DoneStreamSubscription._SCHEDULED;
3241 }
3242 onData(handleData) {}
3243 onError(handleError) {}
3244 onDone(handleDone) {
3245 this[_onDone] = handleDone;
3246 }
3247 pause(resumeSignal) {
3248 if (resumeSignal === void 0)
3249 resumeSignal = null;
3250 this[_state] = _DoneStreamSubscription._PAUSED;
3251 if (resumeSignal !== null)
3252 resumeSignal.whenComplete(this.resume);
3253 }
3254 resume() {
3255 if (this.isPaused) {
3256 this[_state] = _DoneStreamSubscription._PAUSED;
3257 if (!dart.notNull(this.isPaused) && !dart.notNull(this[_isSent])) {
3258 this[_schedule]();
3259 }
3260 }
3261 }
3262 cancel() {
3263 return null;
3264 }
3265 asFuture(futureValue) {
3266 if (futureValue === void 0)
3267 futureValue = null;
3268 let result = new _Future();
3269 this[_onDone] = (() => {
3270 result._completeWithValue(null);
3271 }).bind(this);
3272 return result;
3273 }
3274 [_sendDone]() {
3275 this[_state] = ~dart.notNull(_DoneStreamSubscription._SCHEDULED);
3276 if (this.isPaused)
3277 return;
3278 this[_state] = _DoneStreamSubscription._DONE_SENT;
3279 if (this[_onDone] !== null)
3280 this[_zone].runGuarded(this[_onDone]);
3281 }
3282 }
3283 _DoneStreamSubscription._DONE_SENT = 1;
3284 _DoneStreamSubscription._SCHEDULED = 2;
3285 _DoneStreamSubscription._PAUSED = 4;
3286 return _DoneStreamSubscription;
3287 });
3288 let _DoneStreamSubscription = _DoneStreamSubscription$(dart.dynamic);
3289 let _source = Symbol('_source');
3290 let _onListenHandler = Symbol('_onListenHandler');
3291 let _onCancelHandler = Symbol('_onCancelHandler');
3292 let _cancelSubscription = Symbol('_cancelSubscription');
3293 let _pauseSubscription = Symbol('_pauseSubscription');
3294 let _resumeSubscription = Symbol('_resumeSubscription');
3295 let _isSubscriptionPaused = Symbol('_isSubscriptionPaused');
3296 let _AsBroadcastStream$ = dart.generic(function(T) {
3297 class _AsBroadcastStream extends Stream$(T) {
3298 _AsBroadcastStream($_source, onListenHandler, onCancelHandler) {
3299 this[_source] = $_source;
3300 this[_onListenHandler] = dart.closureWrap(Zone.current.registerUnaryCall back(onListenHandler), "(StreamSubscription<dynamic>) → void");
3301 this[_onCancelHandler] = dart.closureWrap(Zone.current.registerUnaryCall back(onCancelHandler), "(StreamSubscription<dynamic>) → void");
3302 this[_zone] = Zone.current;
3303 this[_controller] = null;
3304 this[_subscription] = null;
3305 super.Stream();
3306 this[_controller] = new _AsBroadcastStreamController(this[_onListen], th is[_onCancel]);
3307 }
3308 get isBroadcast() {
3309 return true;
3310 }
3311 listen(onData, opt$) {
3312 let onError = opt$.onError === void 0 ? null : opt$.onError;
3313 let onDone = opt$.onDone === void 0 ? null : opt$.onDone;
3314 let cancelOnError = opt$.cancelOnError === void 0 ? null : opt$.cancelOn Error;
3315 if (dart.notNull(this[_controller] === null) || dart.notNull(this[_contr oller].isClosed)) {
3316 return new _DoneStreamSubscription(onDone);
3317 }
3318 if (this[_subscription] === null) {
3319 this[_subscription] = this[_source].listen(this[_controller].add, {onE rror: this[_controller].addError, onDone: this[_controller].close});
3320 }
3321 cancelOnError = core.identical(true, cancelOnError);
3322 return this[_controller]._subscribe(onData, onError, onDone, cancelOnErr or);
3323 }
3324 [_onCancel]() {
3325 let shutdown = dart.notNull(this[_controller] === null) || dart.notNull( this[_controller].isClosed);
3326 if (this[_onCancelHandler] !== null) {
3327 this[_zone].runUnary(this[_onCancelHandler], new _BroadcastSubscriptio nWrapper(this));
3328 }
3329 if (shutdown) {
3330 if (this[_subscription] !== null) {
3331 this[_subscription].cancel();
3332 this[_subscription] = null;
3333 }
3334 }
3335 }
3336 [_onListen]() {
3337 if (this[_onListenHandler] !== null) {
3338 this[_zone].runUnary(this[_onListenHandler], new _BroadcastSubscriptio nWrapper(this));
3339 }
3340 }
3341 [_cancelSubscription]() {
3342 if (this[_subscription] === null)
3343 return;
3344 let subscription = this[_subscription];
3345 this[_subscription] = null;
3346 this[_controller] = null;
3347 subscription.cancel();
3348 }
3349 [_pauseSubscription](resumeSignal) {
3350 if (this[_subscription] === null)
3351 return;
3352 this[_subscription].pause(resumeSignal);
3353 }
3354 [_resumeSubscription]() {
3355 if (this[_subscription] === null)
3356 return;
3357 this[_subscription].resume();
3358 }
3359 get [_isSubscriptionPaused]() {
3360 if (this[_subscription] === null)
3361 return false;
3362 return this[_subscription].isPaused;
3363 }
3364 }
3365 return _AsBroadcastStream;
3366 });
3367 let _AsBroadcastStream = _AsBroadcastStream$(dart.dynamic);
3368 let _BroadcastSubscriptionWrapper$ = dart.generic(function(T) {
3369 class _BroadcastSubscriptionWrapper extends core.Object {
3370 _BroadcastSubscriptionWrapper($_stream) {
3371 this[_stream] = $_stream;
3372 }
3373 onData(handleData) {
3374 throw new core.UnsupportedError("Cannot change handlers of asBroadcastSt ream source subscription.");
3375 }
3376 onError(handleError) {
3377 throw new core.UnsupportedError("Cannot change handlers of asBroadcastSt ream source subscription.");
3378 }
3379 onDone(handleDone) {
3380 throw new core.UnsupportedError("Cannot change handlers of asBroadcastSt ream source subscription.");
3381 }
3382 pause(resumeSignal) {
3383 if (resumeSignal === void 0)
3384 resumeSignal = null;
3385 this[_stream]._pauseSubscription(resumeSignal);
3386 }
3387 resume() {
3388 this[_stream]._resumeSubscription();
3389 }
3390 cancel() {
3391 this[_stream]._cancelSubscription();
3392 return null;
3393 }
3394 get isPaused() {
3395 return this[_stream][_isSubscriptionPaused];
3396 }
3397 asFuture(futureValue) {
3398 if (futureValue === void 0)
3399 futureValue = null;
3400 throw new core.UnsupportedError("Cannot change handlers of asBroadcastSt ream source subscription.");
3401 }
3402 }
3403 return _BroadcastSubscriptionWrapper;
3404 });
3405 let _BroadcastSubscriptionWrapper = _BroadcastSubscriptionWrapper$(dart.dynami c);
3406 let _current = Symbol('_current');
3407 let _futureOrPrefetch = Symbol('_futureOrPrefetch');
3408 let _clear = Symbol('_clear');
3409 let _StreamIteratorImpl$ = dart.generic(function(T) {
3410 class _StreamIteratorImpl extends core.Object {
3411 _StreamIteratorImpl(stream) {
3412 this[_subscription] = null;
3413 this[_current] = null;
3414 this[_futureOrPrefetch] = null;
3415 this[_state] = _StreamIteratorImpl._STATE_FOUND;
3416 this[_subscription] = stream.listen(this[_onData], {onError: this[_onErr or], onDone: this[_onDone], cancelOnError: true});
3417 }
3418 get current() {
3419 return this[_current];
3420 }
3421 moveNext() {
3422 if (this[_state] === _StreamIteratorImpl._STATE_DONE) {
3423 return new _Future.immediate(false);
3424 }
3425 if (this[_state] === _StreamIteratorImpl._STATE_MOVING) {
3426 throw new core.StateError("Already waiting for next.");
3427 }
3428 if (this[_state] === _StreamIteratorImpl._STATE_FOUND) {
3429 this[_state] = _StreamIteratorImpl._STATE_MOVING;
3430 this[_current] = null;
3431 this[_futureOrPrefetch] = new _Future();
3432 return dart.as(this[_futureOrPrefetch], Future$(core.bool));
3433 } else {
3434 dart.assert(dart.notNull(this[_state]) >= dart.notNull(_StreamIterator Impl._STATE_EXTRA_DATA));
3435 switch (this[_state]) {
3436 case _StreamIteratorImpl._STATE_EXTRA_DATA:
3437 this[_state] = _StreamIteratorImpl._STATE_FOUND;
3438 this[_current] = dart.as(this[_futureOrPrefetch], T);
3439 this[_futureOrPrefetch] = null;
3440 this[_subscription].resume();
3441 return new _Future.immediate(true);
3442 case _StreamIteratorImpl._STATE_EXTRA_ERROR:
3443 let prefetch = dart.as(this[_futureOrPrefetch], AsyncError);
3444 this[_clear]();
3445 return new _Future.immediateError(prefetch.error, prefetch.stackTr ace);
3446 case _StreamIteratorImpl._STATE_EXTRA_DONE:
3447 this[_clear]();
3448 return new _Future.immediate(false);
3449 }
3450 }
3451 }
3452 [_clear]() {
3453 this[_subscription] = null;
3454 this[_futureOrPrefetch] = null;
3455 this[_current] = null;
3456 this[_state] = _StreamIteratorImpl._STATE_DONE;
3457 }
3458 cancel() {
3459 let subscription = this[_subscription];
3460 if (this[_state] === _StreamIteratorImpl._STATE_MOVING) {
3461 let hasNext = dart.as(this[_futureOrPrefetch], _Future$(core.bool));
3462 this[_clear]();
3463 hasNext._complete(false);
3464 } else {
3465 this[_clear]();
3466 }
3467 return subscription.cancel();
3468 }
3469 [_onData](data) {
3470 if (this[_state] === _StreamIteratorImpl._STATE_MOVING) {
3471 this[_current] = data;
3472 let hasNext = dart.as(this[_futureOrPrefetch], _Future$(core.bool));
3473 this[_futureOrPrefetch] = null;
3474 this[_state] = _StreamIteratorImpl._STATE_FOUND;
3475 hasNext._complete(true);
3476 return;
3477 }
3478 this[_subscription].pause();
3479 dart.assert(this[_futureOrPrefetch] === null);
3480 this[_futureOrPrefetch] = data;
3481 this[_state] = _StreamIteratorImpl._STATE_EXTRA_DATA;
3482 }
3483 [_onError](error, stackTrace) {
3484 if (stackTrace === void 0)
3485 stackTrace = null;
3486 if (this[_state] === _StreamIteratorImpl._STATE_MOVING) {
3487 let hasNext = dart.as(this[_futureOrPrefetch], _Future$(core.bool));
3488 this[_clear]();
3489 hasNext._completeError(error, stackTrace);
3490 return;
3491 }
3492 this[_subscription].pause();
3493 dart.assert(this[_futureOrPrefetch] === null);
3494 this[_futureOrPrefetch] = new AsyncError(error, stackTrace);
3495 this[_state] = _StreamIteratorImpl._STATE_EXTRA_ERROR;
3496 }
3497 [_onDone]() {
3498 if (this[_state] === _StreamIteratorImpl._STATE_MOVING) {
3499 let hasNext = dart.as(this[_futureOrPrefetch], _Future$(core.bool));
3500 this[_clear]();
3501 hasNext._complete(false);
3502 return;
3503 }
3504 this[_subscription].pause();
3505 this[_futureOrPrefetch] = null;
3506 this[_state] = _StreamIteratorImpl._STATE_EXTRA_DONE;
3507 }
3508 }
3509 _StreamIteratorImpl._STATE_FOUND = 0;
3510 _StreamIteratorImpl._STATE_DONE = 1;
3511 _StreamIteratorImpl._STATE_MOVING = 2;
3512 _StreamIteratorImpl._STATE_EXTRA_DATA = 3;
3513 _StreamIteratorImpl._STATE_EXTRA_ERROR = 4;
3514 _StreamIteratorImpl._STATE_EXTRA_DONE = 5;
3515 return _StreamIteratorImpl;
3516 });
3517 let _StreamIteratorImpl = _StreamIteratorImpl$(dart.dynamic);
3518 // Function _runUserCode: (() → dynamic, (dynamic) → dynamic, (dynamic, StackT race) → dynamic) → dynamic
3519 function _runUserCode(userCode, onSuccess, onError) {
3520 try {
3521 dart.dinvokef(onSuccess, userCode());
3522 } catch (e) {
3523 let s = dart.stackTrace(e);
3524 let replacement = Zone.current.errorCallback(e, s);
3525 if (replacement === null) {
3526 dart.dinvokef(onError, e, s);
3527 } else {
3528 let error = _nonNullError(replacement.error);
3529 let stackTrace = replacement.stackTrace;
3530 dart.dinvokef(onError, error, stackTrace);
3531 }
3532 }
3533
3534 }
3535 // Function _cancelAndError: (StreamSubscription<dynamic>, _Future<dynamic>, d ynamic, StackTrace) → void
3536 function _cancelAndError(subscription, future, error, stackTrace) {
3537 let cancelFuture = subscription.cancel();
3538 if (dart.is(cancelFuture, Future)) {
3539 cancelFuture.whenComplete(() => future._completeError(error, stackTrace));
3540 } else {
3541 future._completeError(error, stackTrace);
3542 }
3543 }
3544 // Function _cancelAndErrorWithReplacement: (StreamSubscription<dynamic>, _Fut ure<dynamic>, dynamic, StackTrace) → void
3545 function _cancelAndErrorWithReplacement(subscription, future, error, stackTrac e) {
3546 let replacement = Zone.current.errorCallback(error, stackTrace);
3547 if (replacement !== null) {
3548 error = _nonNullError(replacement.error);
3549 stackTrace = replacement.stackTrace;
3550 }
3551 _cancelAndError(subscription, future, error, stackTrace);
3552 }
3553 // Function _cancelAndErrorClosure: (StreamSubscription<dynamic>, _Future<dyna mic>) → dynamic
3554 function _cancelAndErrorClosure(subscription, future) {
3555 return (error, stackTrace) => _cancelAndError(subscription, future, error, s tackTrace);
3556 }
3557 // Function _cancelAndValue: (StreamSubscription<dynamic>, _Future<dynamic>, d ynamic) → void
3558 function _cancelAndValue(subscription, future, value) {
3559 let cancelFuture = subscription.cancel();
3560 if (dart.is(cancelFuture, Future)) {
3561 cancelFuture.whenComplete(() => future._complete(value));
3562 } else {
3563 future._complete(value);
3564 }
3565 }
3566 let _handleData = Symbol('_handleData');
3567 let _handleError = Symbol('_handleError');
3568 let _handleDone = Symbol('_handleDone');
3569 let _ForwardingStream$ = dart.generic(function(S, T) {
3570 class _ForwardingStream extends Stream$(T) {
3571 _ForwardingStream($_source) {
3572 this[_source] = $_source;
3573 super.Stream();
3574 }
3575 get isBroadcast() {
3576 return this[_source].isBroadcast;
3577 }
3578 listen(onData, opt$) {
3579 let onError = opt$.onError === void 0 ? null : opt$.onError;
3580 let onDone = opt$.onDone === void 0 ? null : opt$.onDone;
3581 let cancelOnError = opt$.cancelOnError === void 0 ? null : opt$.cancelOn Error;
3582 cancelOnError = core.identical(true, cancelOnError);
3583 return this[_createSubscription](onData, onError, onDone, cancelOnError) ;
3584 }
3585 [_createSubscription](onData, onError, onDone, cancelOnError) {
3586 return new _ForwardingStreamSubscription(this, onData, onError, onDone, cancelOnError);
3587 }
3588 [_handleData](data, sink) {
3589 let outputData = data;
3590 sink._add(outputData);
3591 }
3592 [_handleError](error, stackTrace, sink) {
3593 sink._addError(error, stackTrace);
3594 }
3595 [_handleDone](sink) {
3596 sink._close();
3597 }
3598 }
3599 return _ForwardingStream;
3600 });
3601 let _ForwardingStream = _ForwardingStream$(dart.dynamic, dart.dynamic);
3602 let _ForwardingStreamSubscription$ = dart.generic(function(S, T) {
3603 class _ForwardingStreamSubscription extends _BufferingStreamSubscription$(T) {
3604 _ForwardingStreamSubscription($_stream, onData, onError, onDone, cancelOnE rror) {
3605 this[_stream] = $_stream;
3606 this[_subscription] = null;
3607 super._BufferingStreamSubscription(onData, onError, onDone, cancelOnErro r);
3608 this[_subscription] = this[_stream][_source].listen(this[_handleData], { onError: this[_handleError], onDone: this[_handleDone]});
3609 }
3610 [_add](data) {
3611 if (this[_isClosed])
3612 return;
3613 super._add(data);
3614 }
3615 [_addError](error, stackTrace) {
3616 if (this[_isClosed])
3617 return;
3618 super._addError(error, stackTrace);
3619 }
3620 [_onPause]() {
3621 if (this[_subscription] === null)
3622 return;
3623 this[_subscription].pause();
3624 }
3625 [_onResume]() {
3626 if (this[_subscription] === null)
3627 return;
3628 this[_subscription].resume();
3629 }
3630 [_onCancel]() {
3631 if (this[_subscription] !== null) {
3632 let subscription = this[_subscription];
3633 this[_subscription] = null;
3634 subscription.cancel();
3635 }
3636 return null;
3637 }
3638 [_handleData](data) {
3639 this[_stream]._handleData(data, this);
3640 }
3641 [_handleError](error, stackTrace) {
3642 this[_stream]._handleError(error, stackTrace, this);
3643 }
3644 [_handleDone]() {
3645 this[_stream]._handleDone(this);
3646 }
3647 }
3648 return _ForwardingStreamSubscription;
3649 });
3650 let _ForwardingStreamSubscription = _ForwardingStreamSubscription$(dart.dynami c, dart.dynamic);
3651 // Function _addErrorWithReplacement: (_EventSink<dynamic>, dynamic, dynamic) → void
3652 function _addErrorWithReplacement(sink, error, stackTrace) {
3653 let replacement = Zone.current.errorCallback(error, dart.as(stackTrace, core .StackTrace));
3654 if (replacement !== null) {
3655 error = _nonNullError(replacement.error);
3656 stackTrace = replacement.stackTrace;
3657 }
3658 sink._addError(error, dart.as(stackTrace, core.StackTrace));
3659 }
3660 let _test = Symbol('_test');
3661 let _WhereStream$ = dart.generic(function(T) {
3662 class _WhereStream extends _ForwardingStream$(T, T) {
3663 _WhereStream(source, test) {
3664 this[_test] = test;
3665 super._ForwardingStream(source);
3666 }
3667 [_handleData](inputEvent, sink) {
3668 let satisfies = null;
3669 try {
3670 satisfies = this[_test](inputEvent);
3671 } catch (e) {
3672 let s = dart.stackTrace(e);
3673 _addErrorWithReplacement(sink, e, s);
3674 return;
3675 }
3676
3677 if (satisfies) {
3678 sink._add(inputEvent);
3679 }
3680 }
3681 }
3682 return _WhereStream;
3683 });
3684 let _WhereStream = _WhereStream$(dart.dynamic);
3685 let _transform = Symbol('_transform');
3686 let _MapStream$ = dart.generic(function(S, T) {
3687 class _MapStream extends _ForwardingStream$(S, T) {
3688 _MapStream(source, transform) {
3689 this[_transform] = transform;
3690 super._ForwardingStream(source);
3691 }
3692 [_handleData](inputEvent, sink) {
3693 let outputEvent = null;
3694 try {
3695 outputEvent = dart.as(dart.dinvokef(this[_transform], inputEvent), T);
3696 } catch (e) {
3697 let s = dart.stackTrace(e);
3698 _addErrorWithReplacement(sink, e, s);
3699 return;
3700 }
3701
3702 sink._add(outputEvent);
3703 }
3704 }
3705 return _MapStream;
3706 });
3707 let _MapStream = _MapStream$(dart.dynamic, dart.dynamic);
3708 let _expand = Symbol('_expand');
3709 let _ExpandStream$ = dart.generic(function(S, T) {
3710 class _ExpandStream extends _ForwardingStream$(S, T) {
3711 _ExpandStream(source, expand) {
3712 this[_expand] = expand;
3713 super._ForwardingStream(source);
3714 }
3715 [_handleData](inputEvent, sink) {
3716 try {
3717 for (let value of this[_expand](inputEvent)) {
3718 sink._add(value);
3719 }
3720 } catch (e) {
3721 let s = dart.stackTrace(e);
3722 _addErrorWithReplacement(sink, e, s);
3723 }
3724
3725 }
3726 }
3727 return _ExpandStream;
3728 });
3729 let _ExpandStream = _ExpandStream$(dart.dynamic, dart.dynamic);
3730 let _HandleErrorStream$ = dart.generic(function(T) {
3731 class _HandleErrorStream extends _ForwardingStream$(T, T) {
3732 _HandleErrorStream(source, onError, test) {
3733 this[_transform] = onError;
3734 this[_test] = test;
3735 super._ForwardingStream(source);
3736 }
3737 [_handleError](error, stackTrace, sink) {
3738 let matches = true;
3739 if (this[_test] !== null) {
3740 try {
3741 matches = dart.dinvokef(this[_test], error);
3742 } catch (e) {
3743 let s = dart.stackTrace(e);
3744 _addErrorWithReplacement(sink, e, s);
3745 return;
3746 }
3747
3748 }
3749 if (matches) {
3750 try {
3751 _invokeErrorHandler(this[_transform], error, stackTrace);
3752 } catch (e) {
3753 let s = dart.stackTrace(e);
3754 if (core.identical(e, error)) {
3755 sink._addError(error, stackTrace);
3756 } else {
3757 _addErrorWithReplacement(sink, e, s);
3758 }
3759 return;
3760 }
3761
3762 } else {
3763 sink._addError(error, stackTrace);
3764 }
3765 }
3766 }
3767 return _HandleErrorStream;
3768 });
3769 let _HandleErrorStream = _HandleErrorStream$(dart.dynamic);
3770 let _remaining = Symbol('_remaining');
3771 let _TakeStream$ = dart.generic(function(T) {
3772 class _TakeStream extends _ForwardingStream$(T, T) {
3773 _TakeStream(source, count) {
3774 this[_remaining] = count;
3775 super._ForwardingStream(source);
3776 if (!(typeof count == number))
3777 throw new core.ArgumentError(count);
3778 }
3779 [_handleData](inputEvent, sink) {
3780 if (dart.notNull(this[_remaining]) > 0) {
3781 sink._add(inputEvent);
3782 this[_remaining] = 1;
3783 if (this[_remaining] === 0) {
3784 sink._close();
3785 }
3786 }
3787 }
3788 }
3789 return _TakeStream;
3790 });
3791 let _TakeStream = _TakeStream$(dart.dynamic);
3792 let _TakeWhileStream$ = dart.generic(function(T) {
3793 class _TakeWhileStream extends _ForwardingStream$(T, T) {
3794 _TakeWhileStream(source, test) {
3795 this[_test] = test;
3796 super._ForwardingStream(source);
3797 }
3798 [_handleData](inputEvent, sink) {
3799 let satisfies = null;
3800 try {
3801 satisfies = this[_test](inputEvent);
3802 } catch (e) {
3803 let s = dart.stackTrace(e);
3804 _addErrorWithReplacement(sink, e, s);
3805 sink._close();
3806 return;
3807 }
3808
3809 if (satisfies) {
3810 sink._add(inputEvent);
3811 } else {
3812 sink._close();
3813 }
3814 }
3815 }
3816 return _TakeWhileStream;
3817 });
3818 let _TakeWhileStream = _TakeWhileStream$(dart.dynamic);
3819 let _SkipStream$ = dart.generic(function(T) {
3820 class _SkipStream extends _ForwardingStream$(T, T) {
3821 _SkipStream(source, count) {
3822 this[_remaining] = count;
3823 super._ForwardingStream(source);
3824 if (dart.notNull(!(typeof count == number)) || dart.notNull(count) < 0)
3825 throw new core.ArgumentError(count);
3826 }
3827 [_handleData](inputEvent, sink) {
3828 if (dart.notNull(this[_remaining]) > 0) {
3829 this[_remaining] = dart.notNull(this[_remaining]) - 1;
3830 return;
3831 }
3832 sink._add(inputEvent);
3833 }
3834 }
3835 return _SkipStream;
3836 });
3837 let _SkipStream = _SkipStream$(dart.dynamic);
3838 let _hasFailed = Symbol('_hasFailed');
3839 let _SkipWhileStream$ = dart.generic(function(T) {
3840 class _SkipWhileStream extends _ForwardingStream$(T, T) {
3841 _SkipWhileStream(source, test) {
3842 this[_test] = test;
3843 this[_hasFailed] = false;
3844 super._ForwardingStream(source);
3845 }
3846 [_handleData](inputEvent, sink) {
3847 if (this[_hasFailed]) {
3848 sink._add(inputEvent);
3849 return;
3850 }
3851 let satisfies = null;
3852 try {
3853 satisfies = this[_test](inputEvent);
3854 } catch (e) {
3855 let s = dart.stackTrace(e);
3856 _addErrorWithReplacement(sink, e, s);
3857 this[_hasFailed] = true;
3858 return;
3859 }
3860
3861 if (!dart.notNull(satisfies)) {
3862 this[_hasFailed] = true;
3863 sink._add(inputEvent);
3864 }
3865 }
3866 }
3867 return _SkipWhileStream;
3868 });
3869 let _SkipWhileStream = _SkipWhileStream$(dart.dynamic);
3870 let _equals = Symbol('_equals');
3871 let _DistinctStream$ = dart.generic(function(T) {
3872 class _DistinctStream extends _ForwardingStream$(T, T) {
3873 _DistinctStream(source, equals) {
3874 this[_previous] = _SENTINEL;
3875 this[_equals] = equals;
3876 super._ForwardingStream(source);
3877 }
3878 [_handleData](inputEvent, sink) {
3879 if (core.identical(this[_previous], _SENTINEL)) {
3880 this[_previous] = inputEvent;
3881 return sink._add(inputEvent);
3882 } else {
3883 let isEqual = null;
3884 try {
3885 if (this[_equals] === null) {
3886 isEqual = dart.equals(this[_previous], inputEvent);
3887 } else {
3888 isEqual = this[_equals](dart.as(this[_previous], T), inputEvent);
3889 }
3890 } catch (e) {
3891 let s = dart.stackTrace(e);
3892 _addErrorWithReplacement(sink, e, s);
3893 return null;
3894 }
3895
3896 if (!dart.notNull(isEqual)) {
3897 sink._add(inputEvent);
3898 this[_previous] = inputEvent;
3899 }
3900 }
3901 }
3902 }
3903 dart.defineLazyProperties(_DistinctStream, {
3904 get _SENTINEL() {
3905 return new core.Object();
3906 },
3907 set _SENTINEL(_) {}
3908 });
3909 return _DistinctStream;
3910 });
3911 let _DistinctStream = _DistinctStream$(dart.dynamic);
3912 let _EventSinkWrapper$ = dart.generic(function(T) {
3913 class _EventSinkWrapper extends core.Object {
3914 _EventSinkWrapper($_sink) {
3915 this[_sink] = $_sink;
3916 }
3917 add(data) {
3918 this[_sink]._add(data);
3919 }
3920 addError(error, stackTrace) {
3921 if (stackTrace === void 0)
3922 stackTrace = null;
3923 this[_sink]._addError(error, stackTrace);
3924 }
3925 close() {
3926 this[_sink]._close();
3927 }
3928 }
3929 return _EventSinkWrapper;
3930 });
3931 let _EventSinkWrapper = _EventSinkWrapper$(dart.dynamic);
3932 let _transformerSink = Symbol('_transformerSink');
3933 let _isSubscribed = Symbol('_isSubscribed');
3934 let _SinkTransformerStreamSubscription$ = dart.generic(function(S, T) {
3935 class _SinkTransformerStreamSubscription extends _BufferingStreamSubscriptio n$(T) {
3936 _SinkTransformerStreamSubscription(source, mapper, onData, onError, onDone , cancelOnError) {
3937 this[_transformerSink] = null;
3938 this[_subscription] = null;
3939 super._BufferingStreamSubscription(onData, onError, onDone, cancelOnErro r);
3940 let eventSink = new _EventSinkWrapper(this);
3941 this[_transformerSink] = mapper(eventSink);
3942 this[_subscription] = source.listen(this[_handleData], {onError: this[_h andleError], onDone: this[_handleDone]});
3943 }
3944 get [_isSubscribed]() {
3945 return this[_subscription] !== null;
3946 }
3947 [_add](data) {
3948 if (this[_isClosed]) {
3949 throw new core.StateError("Stream is already closed");
3950 }
3951 super._add(data);
3952 }
3953 [_addError](error, stackTrace) {
3954 if (this[_isClosed]) {
3955 throw new core.StateError("Stream is already closed");
3956 }
3957 super._addError(error, stackTrace);
3958 }
3959 [_close]() {
3960 if (this[_isClosed]) {
3961 throw new core.StateError("Stream is already closed");
3962 }
3963 super._close();
3964 }
3965 [_onPause]() {
3966 if (this[_isSubscribed])
3967 this[_subscription].pause();
3968 }
3969 [_onResume]() {
3970 if (this[_isSubscribed])
3971 this[_subscription].resume();
3972 }
3973 [_onCancel]() {
3974 if (this[_isSubscribed]) {
3975 let subscription = this[_subscription];
3976 this[_subscription] = null;
3977 subscription.cancel();
3978 }
3979 return null;
3980 }
3981 [_handleData](data) {
3982 try {
3983 this[_transformerSink].add(data);
3984 } catch (e) {
3985 let s = dart.stackTrace(e);
3986 this[_addError](e, s);
3987 }
3988
3989 }
3990 [_handleError](error, stackTrace) {
3991 if (stackTrace === void 0)
3992 stackTrace = null;
3993 try {
3994 this[_transformerSink].addError(error, dart.as(stackTrace, core.StackT race));
3995 } catch (e) {
3996 let s = dart.stackTrace(e);
3997 if (core.identical(e, error)) {
3998 this[_addError](error, dart.as(stackTrace, core.StackTrace));
3999 } else {
4000 this[_addError](e, s);
4001 }
4002 }
4003
4004 }
4005 [_handleDone]() {
4006 try {
4007 this[_subscription] = null;
4008 this[_transformerSink].close();
4009 } catch (e) {
4010 let s = dart.stackTrace(e);
4011 this[_addError](e, s);
4012 }
4013
4014 }
4015 }
4016 return _SinkTransformerStreamSubscription;
4017 });
4018 let _SinkTransformerStreamSubscription = _SinkTransformerStreamSubscription$(d art.dynamic, dart.dynamic);
4019 let _sinkMapper = Symbol('_sinkMapper');
4020 let _StreamSinkTransformer$ = dart.generic(function(S, T) {
4021 class _StreamSinkTransformer extends core.Object {
4022 _StreamSinkTransformer($_sinkMapper) {
4023 this[_sinkMapper] = $_sinkMapper;
4024 }
4025 bind(stream) {
4026 return new _BoundSinkStream(stream, this[_sinkMapper]);
4027 }
4028 }
4029 return _StreamSinkTransformer;
4030 });
4031 let _StreamSinkTransformer = _StreamSinkTransformer$(dart.dynamic, dart.dynami c);
4032 let _BoundSinkStream$ = dart.generic(function(S, T) {
4033 class _BoundSinkStream extends Stream$(T) {
4034 get isBroadcast() {
4035 return this[_stream].isBroadcast;
4036 }
4037 _BoundSinkStream($_stream, $_sinkMapper) {
4038 this[_stream] = $_stream;
4039 this[_sinkMapper] = $_sinkMapper;
4040 super.Stream();
4041 }
4042 listen(onData, opt$) {
4043 let onError = opt$.onError === void 0 ? null : opt$.onError;
4044 let onDone = opt$.onDone === void 0 ? null : opt$.onDone;
4045 let cancelOnError = opt$.cancelOnError === void 0 ? null : opt$.cancelOn Error;
4046 cancelOnError = core.identical(true, cancelOnError);
4047 let subscription = dart.as(new _SinkTransformerStreamSubscription(this[_ stream], dart.closureWrap(this[_sinkMapper], "(EventSink<dynamic>) → EventSink") , onData, onError, onDone, cancelOnError), StreamSubscription$(T));
4048 return subscription;
4049 }
4050 }
4051 return _BoundSinkStream;
4052 });
4053 let _BoundSinkStream = _BoundSinkStream$(dart.dynamic, dart.dynamic);
4054 let _HandlerEventSink$ = dart.generic(function(S, T) {
4055 class _HandlerEventSink extends core.Object {
4056 _HandlerEventSink($_handleData, $_handleError, $_handleDone, $_sink) {
4057 this[_handleData] = $_handleData;
4058 this[_handleError] = $_handleError;
4059 this[_handleDone] = $_handleDone;
4060 this[_sink] = $_sink;
4061 }
4062 add(data) {
4063 return this[_handleData](data, this[_sink]);
4064 }
4065 addError(error, stackTrace) {
4066 if (stackTrace === void 0)
4067 stackTrace = null;
4068 return this[_handleError](error, stackTrace, this[_sink]);
4069 }
4070 close() {
4071 return this[_handleDone](this[_sink]);
4072 }
4073 }
4074 return _HandlerEventSink;
4075 });
4076 let _HandlerEventSink = _HandlerEventSink$(dart.dynamic, dart.dynamic);
4077 let _defaultHandleData = Symbol('_defaultHandleData');
4078 let _defaultHandleError = Symbol('_defaultHandleError');
4079 let _defaultHandleDone = Symbol('_defaultHandleDone');
4080 let _StreamHandlerTransformer$ = dart.generic(function(S, T) {
4081 class _StreamHandlerTransformer extends _StreamSinkTransformer$(S, T) {
4082 _StreamHandlerTransformer(opt$) {
4083 let handleData = opt$.handleData === void 0 ? null : opt$.handleData;
4084 let handleError = opt$.handleError === void 0 ? null : opt$.handleError;
4085 let handleDone = opt$.handleDone === void 0 ? null : opt$.handleDone;
4086 super._StreamSinkTransformer(dart.closureWrap((outputSink) => {
4087 if (handleData === null)
4088 handleData = dart.closureWrap(_defaultHandleData, "(S, EventSink<T>) → void");
4089 if (handleError === null)
4090 handleError = dart.closureWrap(_defaultHandleError, "(Object, StackT race, EventSink<T>) → void");
4091 if (handleDone === null)
4092 handleDone = _defaultHandleDone;
4093 return new _HandlerEventSink(handleData, handleError, handleDone, outp utSink);
4094 }, "(EventSink<T>) → EventSink<S>"));
4095 }
4096 bind(stream) {
4097 return super.bind(stream);
4098 }
4099 static [_defaultHandleData](data, sink) {
4100 sink.add(data);
4101 }
4102 static [_defaultHandleError](error, stackTrace, sink) {
4103 sink.addError(error);
4104 }
4105 static [_defaultHandleDone](sink) {
4106 sink.close();
4107 }
4108 }
4109 return _StreamHandlerTransformer;
4110 });
4111 let _StreamHandlerTransformer = _StreamHandlerTransformer$(dart.dynamic, dart. dynamic);
4112 let _transformer = Symbol('_transformer');
4113 let _StreamSubscriptionTransformer$ = dart.generic(function(S, T) {
4114 class _StreamSubscriptionTransformer extends core.Object {
4115 _StreamSubscriptionTransformer($_transformer) {
4116 this[_transformer] = $_transformer;
4117 }
4118 bind(stream) {
4119 return new _BoundSubscriptionStream(stream, this[_transformer]);
4120 }
4121 }
4122 return _StreamSubscriptionTransformer;
4123 });
4124 let _StreamSubscriptionTransformer = _StreamSubscriptionTransformer$(dart.dyna mic, dart.dynamic);
4125 let _BoundSubscriptionStream$ = dart.generic(function(S, T) {
4126 class _BoundSubscriptionStream extends Stream$(T) {
4127 _BoundSubscriptionStream($_stream, $_transformer) {
4128 this[_stream] = $_stream;
4129 this[_transformer] = $_transformer;
4130 super.Stream();
4131 }
4132 listen(onData, opt$) {
4133 let onError = opt$.onError === void 0 ? null : opt$.onError;
4134 let onDone = opt$.onDone === void 0 ? null : opt$.onDone;
4135 let cancelOnError = opt$.cancelOnError === void 0 ? null : opt$.cancelOn Error;
4136 cancelOnError = core.identical(true, cancelOnError);
4137 let result = this[_transformer](this[_stream], cancelOnError);
4138 result.onData(onData);
4139 result.onError(onError);
4140 result.onDone(onDone);
4141 return result;
4142 }
4143 }
4144 return _BoundSubscriptionStream;
4145 });
4146 let _BoundSubscriptionStream = _BoundSubscriptionStream$(dart.dynamic, dart.dy namic);
4147 let _createTimer = Symbol('_createTimer');
4148 let _createPeriodicTimer = Symbol('_createPeriodicTimer');
4149 class Timer extends core.Object {
4150 Timer(duration, callback) {
4151 if (dart.equals(Zone.current, Zone.ROOT)) {
4152 return Zone.current.createTimer(duration, callback);
4153 }
4154 return Zone.current.createTimer(duration, Zone.current.bindCallback(callba ck, {runGuarded: true}));
4155 }
4156 Timer$periodic(duration, callback) {
4157 if (dart.equals(Zone.current, Zone.ROOT)) {
4158 return Zone.current.createPeriodicTimer(duration, callback);
4159 }
4160 return Zone.current.createPeriodicTimer(duration, dart.closureWrap(Zone.cu rrent.bindUnaryCallback(callback, {runGuarded: true}), "(Timer) → void"));
4161 }
4162 static run(callback) {
4163 new Timer(core.Duration.ZERO, callback);
4164 }
4165 static [_createTimer](duration, callback) {
4166 let milliseconds = duration.inMilliseconds;
4167 if (dart.notNull(milliseconds) < 0)
4168 milliseconds = 0;
4169 return new _isolate_helper.TimerImpl(milliseconds, callback);
4170 }
4171 static [_createPeriodicTimer](duration, callback) {
4172 let milliseconds = duration.inMilliseconds;
4173 if (dart.notNull(milliseconds) < 0)
4174 milliseconds = 0;
4175 return new _isolate_helper.TimerImpl.periodic(milliseconds, callback);
4176 }
4177 }
4178 dart.defineNamedConstructor(Timer, 'periodic');
4179 class _ZoneFunction extends core.Object {
4180 _ZoneFunction(zone, function) {
4181 this.zone = zone;
4182 this['function'] = function;
4183 }
4184 }
4185 class ZoneSpecification extends core.Object {
4186 ZoneSpecification(opt$) {
4187 return new _ZoneSpecification(opt$);
4188 }
4189 ZoneSpecification$from(other, opt$) {
4190 let handleUncaughtError = opt$.handleUncaughtError === void 0 ? null : opt $.handleUncaughtError;
4191 let run = opt$.run === void 0 ? null : opt$.run;
4192 let runUnary = opt$.runUnary === void 0 ? null : opt$.runUnary;
4193 let runBinary = opt$.runBinary === void 0 ? null : opt$.runBinary;
4194 let registerCallback = opt$.registerCallback === void 0 ? null : opt$.regi sterCallback;
4195 let registerUnaryCallback = opt$.registerUnaryCallback === void 0 ? null : opt$.registerUnaryCallback;
4196 let registerBinaryCallback = opt$.registerBinaryCallback === void 0 ? null : opt$.registerBinaryCallback;
4197 let errorCallback = opt$.errorCallback === void 0 ? null : opt$.errorCallb ack;
4198 let scheduleMicrotask = opt$.scheduleMicrotask === void 0 ? null : opt$.sc heduleMicrotask;
4199 let createTimer = opt$.createTimer === void 0 ? null : opt$.createTimer;
4200 let createPeriodicTimer = opt$.createPeriodicTimer === void 0 ? null : opt $.createPeriodicTimer;
4201 let print = opt$.print === void 0 ? null : opt$.print;
4202 let fork = opt$.fork === void 0 ? null : opt$.fork;
4203 return new ZoneSpecification({handleUncaughtError: dart.as(handleUncaughtE rror !== null ? handleUncaughtError : other.handleUncaughtError, dart.throw_("Un implemented type (Zone, ZoneDelegate, Zone, dynamic, StackTrace) → dynamic")), r un: dart.as(run !== null ? run : other.run, dart.throw_("Unimplemented type (Zon e, ZoneDelegate, Zone, () → dynamic) → dynamic")), runUnary: dart.as(runUnary != = null ? runUnary : other.runUnary, dart.throw_("Unimplemented type (Zone, ZoneD elegate, Zone, (dynamic) → dynamic, dynamic) → dynamic")), runBinary: dart.as(ru nBinary !== null ? runBinary : other.runBinary, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, (dynamic, dynamic) → dynamic, dynamic, dynamic) → dyn amic")), registerCallback: dart.as(registerCallback !== null ? registerCallback : other.registerCallback, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Z one, () → dynamic) → ZoneCallback")), registerUnaryCallback: dart.as(registerUna ryCallback !== null ? registerUnaryCallback : other.registerUnaryCallback, dart. throw_("Unimplemented type (Zone, ZoneDelegate, Zone, (dynamic) → dynamic) → Zon eUnaryCallback")), registerBinaryCallback: dart.as(registerBinaryCallback !== nu ll ? registerBinaryCallback : other.registerBinaryCallback, dart.throw_("Unimple mented type (Zone, ZoneDelegate, Zone, (dynamic, dynamic) → dynamic) → ZoneBinar yCallback")), errorCallback: dart.as(errorCallback !== null ? errorCallback : ot her.errorCallback, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, Ob ject, StackTrace) → AsyncError")), scheduleMicrotask: dart.as(scheduleMicrotask !== null ? scheduleMicrotask : other.scheduleMicrotask, dart.throw_("Unimplement ed type (Zone, ZoneDelegate, Zone, () → dynamic) → void")), createTimer: dart.as (createTimer !== null ? createTimer : other.createTimer, dart.throw_("Unimplemen ted type (Zone, ZoneDelegate, Zone, Duration, () → void) → Timer")), createPerio dicTimer: dart.as(createPeriodicTimer !== null ? createPeriodicTimer : other.cre atePeriodicTimer, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, Dur ation, (Timer) → void) → Timer")), print: dart.as(print !== null ? print : other .print, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, String) → voi d")), fork: dart.as(fork !== null ? fork : other.fork, dart.throw_("Unimplemente d type (Zone, ZoneDelegate, Zone, ZoneSpecification, Map<dynamic, dynamic>) → Zo ne"))});
4204 }
4205 }
4206 dart.defineNamedConstructor(ZoneSpecification, 'from');
4207 class _ZoneSpecification extends core.Object {
4208 _ZoneSpecification(opt$) {
4209 let handleUncaughtError = opt$.handleUncaughtError === void 0 ? null : opt $.handleUncaughtError;
4210 let run = opt$.run === void 0 ? null : opt$.run;
4211 let runUnary = opt$.runUnary === void 0 ? null : opt$.runUnary;
4212 let runBinary = opt$.runBinary === void 0 ? null : opt$.runBinary;
4213 let registerCallback = opt$.registerCallback === void 0 ? null : opt$.regi sterCallback;
4214 let registerUnaryCallback = opt$.registerUnaryCallback === void 0 ? null : opt$.registerUnaryCallback;
4215 let registerBinaryCallback = opt$.registerBinaryCallback === void 0 ? null : opt$.registerBinaryCallback;
4216 let errorCallback = opt$.errorCallback === void 0 ? null : opt$.errorCallb ack;
4217 let scheduleMicrotask = opt$.scheduleMicrotask === void 0 ? null : opt$.sc heduleMicrotask;
4218 let createTimer = opt$.createTimer === void 0 ? null : opt$.createTimer;
4219 let createPeriodicTimer = opt$.createPeriodicTimer === void 0 ? null : opt $.createPeriodicTimer;
4220 let print = opt$.print === void 0 ? null : opt$.print;
4221 let fork = opt$.fork === void 0 ? null : opt$.fork;
4222 this.handleUncaughtError = handleUncaughtError;
4223 this.run = run;
4224 this.runUnary = runUnary;
4225 this.runBinary = runBinary;
4226 this.registerCallback = registerCallback;
4227 this.registerUnaryCallback = registerUnaryCallback;
4228 this.registerBinaryCallback = registerBinaryCallback;
4229 this.errorCallback = errorCallback;
4230 this.scheduleMicrotask = scheduleMicrotask;
4231 this.createTimer = createTimer;
4232 this.createPeriodicTimer = createPeriodicTimer;
4233 this.print = print;
4234 this.fork = fork;
4235 }
4236 }
4237 class ZoneDelegate extends core.Object {
4238 }
4239 let _enter = Symbol('_enter');
4240 let _leave = Symbol('_leave');
4241 class Zone extends core.Object {
4242 Zone$_() {
4243 }
4244 static get current() {
4245 return _current;
4246 }
4247 static [_enter](zone) {
4248 dart.assert(zone !== null);
4249 dart.assert(!dart.notNull(core.identical(zone, _current)));
4250 let previous = _current;
4251 _current = zone;
4252 return previous;
4253 }
4254 static [_leave](previous) {
4255 dart.assert(previous !== null);
4256 Zone[_current] = previous;
4257 }
4258 }
4259 dart.defineNamedConstructor(Zone, '_');
4260 Zone.ROOT = _ROOT_ZONE;
4261 Zone._current = _ROOT_ZONE;
4262 let _delegate = Symbol('_delegate');
4263 // Function _parentDelegate: (_Zone) → ZoneDelegate
4264 function _parentDelegate(zone) {
4265 if (zone.parent === null)
4266 return null;
4267 return zone.parent[_delegate];
4268 }
4269 let _delegationTarget = Symbol('_delegationTarget');
4270 let _handleUncaughtError = Symbol('_handleUncaughtError');
4271 let _run = Symbol('_run');
4272 let _runUnary = Symbol('_runUnary');
4273 let _runBinary = Symbol('_runBinary');
4274 let _registerCallback = Symbol('_registerCallback');
4275 let _registerUnaryCallback = Symbol('_registerUnaryCallback');
4276 let _registerBinaryCallback = Symbol('_registerBinaryCallback');
4277 let _errorCallback = Symbol('_errorCallback');
4278 let _scheduleMicrotask = Symbol('_scheduleMicrotask');
4279 let _print = Symbol('_print');
4280 let _fork = Symbol('_fork');
4281 class _ZoneDelegate extends core.Object {
4282 _ZoneDelegate($_delegationTarget) {
4283 this[_delegationTarget] = $_delegationTarget;
4284 }
4285 handleUncaughtError(zone, error, stackTrace) {
4286 let implementation = this[_delegationTarget][_handleUncaughtError];
4287 let implZone = implementation.zone;
4288 return dart.dinvokef(implementation['function'], implZone, _parentDelegate (implZone), zone, error, stackTrace);
4289 }
4290 run(zone, f) {
4291 let implementation = this[_delegationTarget][_run];
4292 let implZone = implementation.zone;
4293 return dart.dinvokef(implementation['function'], implZone, _parentDelegate (implZone), zone, f);
4294 }
4295 runUnary(zone, f, arg) {
4296 let implementation = this[_delegationTarget][_runUnary];
4297 let implZone = implementation.zone;
4298 return dart.dinvokef(implementation['function'], implZone, _parentDelegate (implZone), zone, f, arg);
4299 }
4300 runBinary(zone, f, arg1, arg2) {
4301 let implementation = this[_delegationTarget][_runBinary];
4302 let implZone = implementation.zone;
4303 return dart.dinvokef(implementation['function'], implZone, _parentDelegate (implZone), zone, f, arg1, arg2);
4304 }
4305 registerCallback(zone, f) {
4306 let implementation = this[_delegationTarget][_registerCallback];
4307 let implZone = implementation.zone;
4308 return dart.as(dart.dinvokef(implementation['function'], implZone, _parent Delegate(implZone), zone, f), ZoneCallback);
4309 }
4310 registerUnaryCallback(zone, f) {
4311 let implementation = this[_delegationTarget][_registerUnaryCallback];
4312 let implZone = implementation.zone;
4313 return dart.as(dart.dinvokef(implementation['function'], implZone, _parent Delegate(implZone), zone, f), ZoneUnaryCallback);
4314 }
4315 registerBinaryCallback(zone, f) {
4316 let implementation = this[_delegationTarget][_registerBinaryCallback];
4317 let implZone = implementation.zone;
4318 return dart.as(dart.dinvokef(implementation['function'], implZone, _parent Delegate(implZone), zone, f), ZoneBinaryCallback);
4319 }
4320 errorCallback(zone, error, stackTrace) {
4321 let implementation = this[_delegationTarget][_errorCallback];
4322 let implZone = implementation.zone;
4323 if (core.identical(implZone, _ROOT_ZONE))
4324 return null;
4325 return dart.as(dart.dinvokef(implementation['function'], implZone, _parent Delegate(implZone), zone, error, stackTrace), AsyncError);
4326 }
4327 scheduleMicrotask(zone, f) {
4328 let implementation = this[_delegationTarget][_scheduleMicrotask];
4329 let implZone = implementation.zone;
4330 dart.dinvokef(implementation['function'], implZone, _parentDelegate(implZo ne), zone, f);
4331 }
4332 createTimer(zone, duration, f) {
4333 let implementation = this[_delegationTarget][_createTimer];
4334 let implZone = implementation.zone;
4335 return dart.as(dart.dinvokef(implementation['function'], implZone, _parent Delegate(implZone), zone, duration, f), Timer);
4336 }
4337 createPeriodicTimer(zone, period, f) {
4338 let implementation = this[_delegationTarget][_createPeriodicTimer];
4339 let implZone = implementation.zone;
4340 return dart.as(dart.dinvokef(implementation['function'], implZone, _parent Delegate(implZone), zone, period, f), Timer);
4341 }
4342 print(zone, line) {
4343 let implementation = this[_delegationTarget][_print];
4344 let implZone = implementation.zone;
4345 dart.dinvokef(implementation['function'], implZone, _parentDelegate(implZo ne), zone, line);
4346 }
4347 fork(zone, specification, zoneValues) {
4348 let implementation = this[_delegationTarget][_fork];
4349 let implZone = implementation.zone;
4350 return dart.as(dart.dinvokef(implementation['function'], implZone, _parent Delegate(implZone), zone, specification, zoneValues), Zone);
4351 }
4352 }
4353 class _Zone extends core.Object {
4354 _Zone() {
4355 }
4356 inSameErrorZone(otherZone) {
4357 return dart.notNull(core.identical(this, otherZone)) || dart.notNull(core. identical(this.errorZone, otherZone.errorZone));
4358 }
4359 }
4360 let _delegateCache = Symbol('_delegateCache');
4361 let _map = Symbol('_map');
4362 class _CustomZone extends _Zone {
4363 get [_delegate]() {
4364 if (this[_delegateCache] !== null)
4365 return this[_delegateCache];
4366 this[_delegateCache] = new _ZoneDelegate(this);
4367 return this[_delegateCache];
4368 }
4369 _CustomZone(parent, specification, $_map) {
4370 this.parent = parent;
4371 this[_map] = $_map;
4372 this[_runUnary] = null;
4373 this[_run] = null;
4374 this[_runBinary] = null;
4375 this[_registerCallback] = null;
4376 this[_registerUnaryCallback] = null;
4377 this[_registerBinaryCallback] = null;
4378 this[_errorCallback] = null;
4379 this[_scheduleMicrotask] = null;
4380 this[_createTimer] = null;
4381 this[_createPeriodicTimer] = null;
4382 this[_print] = null;
4383 this[_fork] = null;
4384 this[_handleUncaughtError] = null;
4385 this[_delegateCache] = null;
4386 super._Zone();
4387 this[_run] = specification.run !== null ? new _ZoneFunction(this, specific ation.run) : this.parent[_run];
4388 this[_runUnary] = specification.runUnary !== null ? new _ZoneFunction(this , specification.runUnary) : this.parent[_runUnary];
4389 this[_runBinary] = specification.runBinary !== null ? new _ZoneFunction(th is, specification.runBinary) : this.parent[_runBinary];
4390 this[_registerCallback] = specification.registerCallback !== null ? new _Z oneFunction(this, specification.registerCallback) : this.parent[_registerCallbac k];
4391 this[_registerUnaryCallback] = specification.registerUnaryCallback !== nul l ? new _ZoneFunction(this, specification.registerUnaryCallback) : this.parent[_ registerUnaryCallback];
4392 this[_registerBinaryCallback] = specification.registerBinaryCallback !== n ull ? new _ZoneFunction(this, specification.registerBinaryCallback) : this.paren t[_registerBinaryCallback];
4393 this[_errorCallback] = specification.errorCallback !== null ? new _ZoneFun ction(this, specification.errorCallback) : this.parent[_errorCallback];
4394 this[_scheduleMicrotask] = specification.scheduleMicrotask !== null ? new _ZoneFunction(this, specification.scheduleMicrotask) : this.parent[_scheduleMicr otask];
4395 this[_createTimer] = specification.createTimer !== null ? new _ZoneFunctio n(this, specification.createTimer) : this.parent[_createTimer];
4396 this[_createPeriodicTimer] = specification.createPeriodicTimer !== null ? new _ZoneFunction(this, specification.createPeriodicTimer) : this.parent[_create PeriodicTimer];
4397 this[_print] = specification.print !== null ? new _ZoneFunction(this, spec ification.print) : this.parent[_print];
4398 this[_fork] = specification.fork !== null ? new _ZoneFunction(this, specif ication.fork) : this.parent[_fork];
4399 this[_handleUncaughtError] = specification.handleUncaughtError !== null ? new _ZoneFunction(this, specification.handleUncaughtError) : this.parent[_handle UncaughtError];
4400 }
4401 get errorZone() {
4402 return this[_handleUncaughtError].zone;
4403 }
4404 runGuarded(f) {
4405 try {
4406 return this.run(f);
4407 } catch (e) {
4408 let s = dart.stackTrace(e);
4409 return this.handleUncaughtError(e, s);
4410 }
4411
4412 }
4413 runUnaryGuarded(f, arg) {
4414 try {
4415 return this.runUnary(f, arg);
4416 } catch (e) {
4417 let s = dart.stackTrace(e);
4418 return this.handleUncaughtError(e, s);
4419 }
4420
4421 }
4422 runBinaryGuarded(f, arg1, arg2) {
4423 try {
4424 return this.runBinary(f, arg1, arg2);
4425 } catch (e) {
4426 let s = dart.stackTrace(e);
4427 return this.handleUncaughtError(e, s);
4428 }
4429
4430 }
4431 bindCallback(f, opt$) {
4432 let runGuarded = opt$.runGuarded === void 0 ? true : opt$.runGuarded;
4433 let registered = this.registerCallback(f);
4434 if (runGuarded) {
4435 return (() => this.runGuarded(registered)).bind(this);
4436 } else {
4437 return (() => this.run(registered)).bind(this);
4438 }
4439 }
4440 bindUnaryCallback(f, opt$) {
4441 let runGuarded = opt$.runGuarded === void 0 ? true : opt$.runGuarded;
4442 let registered = this.registerUnaryCallback(f);
4443 if (runGuarded) {
4444 return ((arg) => this.runUnaryGuarded(registered, arg)).bind(this);
4445 } else {
4446 return ((arg) => this.runUnary(registered, arg)).bind(this);
4447 }
4448 }
4449 bindBinaryCallback(f, opt$) {
4450 let runGuarded = opt$.runGuarded === void 0 ? true : opt$.runGuarded;
4451 let registered = this.registerBinaryCallback(f);
4452 if (runGuarded) {
4453 return ((arg1, arg2) => this.runBinaryGuarded(registered, arg1, arg2)).b ind(this);
4454 } else {
4455 return ((arg1, arg2) => this.runBinary(registered, arg1, arg2)).bind(thi s);
4456 }
4457 }
4458 get(key) {
4459 let result = this[_map].get(key);
4460 if (dart.notNull(result !== null) || dart.notNull(this[_map].containsKey(k ey)))
4461 return result;
4462 if (this.parent !== null) {
4463 let value = this.parent.get(key);
4464 if (value !== null) {
4465 this[_map].set(key, value);
4466 }
4467 return value;
4468 }
4469 dart.assert(dart.equals(this, _ROOT_ZONE));
4470 return null;
4471 }
4472 handleUncaughtError(error, stackTrace) {
4473 let implementation = this[_handleUncaughtError];
4474 dart.assert(implementation !== null);
4475 let parentDelegate = _parentDelegate(implementation.zone);
4476 return dart.dinvokef(implementation['function'], implementation.zone, pare ntDelegate, this, error, stackTrace);
4477 }
4478 fork(opt$) {
4479 let specification = opt$.specification === void 0 ? null : opt$.specificat ion;
4480 let zoneValues = opt$.zoneValues === void 0 ? null : opt$.zoneValues;
4481 let implementation = this[_fork];
4482 dart.assert(implementation !== null);
4483 let parentDelegate = _parentDelegate(implementation.zone);
4484 return dart.as(dart.dinvokef(implementation['function'], implementation.zo ne, parentDelegate, this, specification, zoneValues), Zone);
4485 }
4486 run(f) {
4487 let implementation = this[_run];
4488 dart.assert(implementation !== null);
4489 let parentDelegate = _parentDelegate(implementation.zone);
4490 return dart.dinvokef(implementation['function'], implementation.zone, pare ntDelegate, this, f);
4491 }
4492 runUnary(f, arg) {
4493 let implementation = this[_runUnary];
4494 dart.assert(implementation !== null);
4495 let parentDelegate = _parentDelegate(implementation.zone);
4496 return dart.dinvokef(implementation['function'], implementation.zone, pare ntDelegate, this, f, arg);
4497 }
4498 runBinary(f, arg1, arg2) {
4499 let implementation = this[_runBinary];
4500 dart.assert(implementation !== null);
4501 let parentDelegate = _parentDelegate(implementation.zone);
4502 return dart.dinvokef(implementation['function'], implementation.zone, pare ntDelegate, this, f, arg1, arg2);
4503 }
4504 registerCallback(f) {
4505 let implementation = this[_registerCallback];
4506 dart.assert(implementation !== null);
4507 let parentDelegate = _parentDelegate(implementation.zone);
4508 return dart.as(dart.dinvokef(implementation['function'], implementation.zo ne, parentDelegate, this, f), ZoneCallback);
4509 }
4510 registerUnaryCallback(f) {
4511 let implementation = this[_registerUnaryCallback];
4512 dart.assert(implementation !== null);
4513 let parentDelegate = _parentDelegate(implementation.zone);
4514 return dart.as(dart.dinvokef(implementation['function'], implementation.zo ne, parentDelegate, this, f), ZoneUnaryCallback);
4515 }
4516 registerBinaryCallback(f) {
4517 let implementation = this[_registerBinaryCallback];
4518 dart.assert(implementation !== null);
4519 let parentDelegate = _parentDelegate(implementation.zone);
4520 return dart.as(dart.dinvokef(implementation['function'], implementation.zo ne, parentDelegate, this, f), ZoneBinaryCallback);
4521 }
4522 errorCallback(error, stackTrace) {
4523 let implementation = this[_errorCallback];
4524 dart.assert(implementation !== null);
4525 let implementationZone = implementation.zone;
4526 if (core.identical(implementationZone, _ROOT_ZONE))
4527 return null;
4528 let parentDelegate = _parentDelegate(dart.as(implementationZone, _Zone));
4529 return dart.as(dart.dinvokef(implementation['function'], implementationZon e, parentDelegate, this, error, stackTrace), AsyncError);
4530 }
4531 scheduleMicrotask(f) {
4532 let implementation = this[_scheduleMicrotask];
4533 dart.assert(implementation !== null);
4534 let parentDelegate = _parentDelegate(implementation.zone);
4535 return dart.dinvokef(implementation['function'], implementation.zone, pare ntDelegate, this, f);
4536 }
4537 createTimer(duration, f) {
4538 let implementation = this[_createTimer];
4539 dart.assert(implementation !== null);
4540 let parentDelegate = _parentDelegate(implementation.zone);
4541 return dart.as(dart.dinvokef(implementation['function'], implementation.zo ne, parentDelegate, this, duration, f), Timer);
4542 }
4543 createPeriodicTimer(duration, f) {
4544 let implementation = this[_createPeriodicTimer];
4545 dart.assert(implementation !== null);
4546 let parentDelegate = _parentDelegate(implementation.zone);
4547 return dart.as(dart.dinvokef(implementation['function'], implementation.zo ne, parentDelegate, this, duration, f), Timer);
4548 }
4549 print(line) {
4550 let implementation = this[_print];
4551 dart.assert(implementation !== null);
4552 let parentDelegate = _parentDelegate(implementation.zone);
4553 return dart.dinvokef(implementation['function'], implementation.zone, pare ntDelegate, this, line);
4554 }
4555 }
4556 // Function _rootHandleUncaughtError: (Zone, ZoneDelegate, Zone, dynamic, Stac kTrace) → void
4557 function _rootHandleUncaughtError(self, parent, zone, error, stackTrace) {
4558 _schedulePriorityAsyncCallback(() => {
4559 throw new _UncaughtAsyncError(error, stackTrace);
4560 });
4561 }
4562 // Function _rootRun: (Zone, ZoneDelegate, Zone, () → dynamic) → dynamic
4563 function _rootRun(self, parent, zone, f) {
4564 if (dart.equals(Zone[_current], zone))
4565 return f();
4566 let old = Zone._enter(zone);
4567 try {
4568 return f();
4569 } finally {
4570 Zone._leave(old);
4571 }
4572 }
4573 // Function _rootRunUnary: (Zone, ZoneDelegate, Zone, (dynamic) → dynamic, dyn amic) → dynamic
4574 function _rootRunUnary(self, parent, zone, f, arg) {
4575 if (dart.equals(Zone[_current], zone))
4576 return dart.dinvokef(f, arg);
4577 let old = Zone._enter(zone);
4578 try {
4579 return dart.dinvokef(f, arg);
4580 } finally {
4581 Zone._leave(old);
4582 }
4583 }
4584 // Function _rootRunBinary: (Zone, ZoneDelegate, Zone, (dynamic, dynamic) → dy namic, dynamic, dynamic) → dynamic
4585 function _rootRunBinary(self, parent, zone, f, arg1, arg2) {
4586 if (dart.equals(Zone[_current], zone))
4587 return dart.dinvokef(f, arg1, arg2);
4588 let old = Zone._enter(zone);
4589 try {
4590 return dart.dinvokef(f, arg1, arg2);
4591 } finally {
4592 Zone._leave(old);
4593 }
4594 }
4595 // Function _rootRegisterCallback: (Zone, ZoneDelegate, Zone, () → dynamic) → ZoneCallback
4596 function _rootRegisterCallback(self, parent, zone, f) {
4597 return f;
4598 }
4599 // Function _rootRegisterUnaryCallback: (Zone, ZoneDelegate, Zone, (dynamic) → dynamic) → ZoneUnaryCallback
4600 function _rootRegisterUnaryCallback(self, parent, zone, f) {
4601 return f;
4602 }
4603 // Function _rootRegisterBinaryCallback: (Zone, ZoneDelegate, Zone, (dynamic, dynamic) → dynamic) → ZoneBinaryCallback
4604 function _rootRegisterBinaryCallback(self, parent, zone, f) {
4605 return f;
4606 }
4607 // Function _rootErrorCallback: (Zone, ZoneDelegate, Zone, Object, StackTrace) → AsyncError
4608 function _rootErrorCallback(self, parent, zone, error, stackTrace) {
4609 return null;
4610 }
4611 // Function _rootScheduleMicrotask: (Zone, ZoneDelegate, Zone, () → dynamic) → void
4612 function _rootScheduleMicrotask(self, parent, zone, f) {
4613 if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
4614 let hasErrorHandler = !dart.notNull(_ROOT_ZONE.inSameErrorZone(zone));
4615 f = zone.bindCallback(f, {runGuarded: hasErrorHandler});
4616 }
4617 _scheduleAsyncCallback(f);
4618 }
4619 // Function _rootCreateTimer: (Zone, ZoneDelegate, Zone, Duration, () → void) → Timer
4620 function _rootCreateTimer(self, parent, zone, duration, callback) {
4621 if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
4622 callback = zone.bindCallback(callback);
4623 }
4624 return Timer._createTimer(duration, callback);
4625 }
4626 // Function _rootCreatePeriodicTimer: (Zone, ZoneDelegate, Zone, Duration, (Ti mer) → void) → Timer
4627 function _rootCreatePeriodicTimer(self, parent, zone, duration, callback) {
4628 if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
4629 callback = dart.closureWrap(zone.bindUnaryCallback(callback), "(Timer) → v oid");
4630 }
4631 return Timer._createPeriodicTimer(duration, callback);
4632 }
4633 // Function _rootPrint: (Zone, ZoneDelegate, Zone, String) → void
4634 function _rootPrint(self, parent, zone, line) {
4635 _internal.printToConsole(line);
4636 }
4637 // Function _printToZone: (String) → void
4638 function _printToZone(line) {
4639 Zone.current.print(line);
4640 }
4641 // Function _rootFork: (Zone, ZoneDelegate, Zone, ZoneSpecification, Map<dynam ic, dynamic>) → Zone
4642 function _rootFork(self, parent, zone, specification, zoneValues) {
4643 _internal.printToZone = _printToZone;
4644 if (specification === null) {
4645 specification = new ZoneSpecification();
4646 } else if (!dart.is(specification, _ZoneSpecification)) {
4647 throw new core.ArgumentError("ZoneSpecifications must be instantiated" + " with the provided constructor.");
4648 }
4649 let valueMap = null;
4650 if (zoneValues === null) {
4651 if (dart.is(zone, _Zone)) {
4652 valueMap = zone[_map];
4653 } else {
4654 valueMap = new collection.HashMap();
4655 }
4656 } else {
4657 valueMap = new collection.HashMap.from(zoneValues);
4658 }
4659 return new _CustomZone(dart.as(zone, _Zone), specification, valueMap);
4660 }
4661 class _RootZoneSpecification extends core.Object {
4662 get handleUncaughtError() {
4663 return _rootHandleUncaughtError;
4664 }
4665 get run() {
4666 return _rootRun;
4667 }
4668 get runUnary() {
4669 return _rootRunUnary;
4670 }
4671 get runBinary() {
4672 return _rootRunBinary;
4673 }
4674 get registerCallback() {
4675 return _rootRegisterCallback;
4676 }
4677 get registerUnaryCallback() {
4678 return _rootRegisterUnaryCallback;
4679 }
4680 get registerBinaryCallback() {
4681 return _rootRegisterBinaryCallback;
4682 }
4683 get errorCallback() {
4684 return _rootErrorCallback;
4685 }
4686 get scheduleMicrotask() {
4687 return _rootScheduleMicrotask;
4688 }
4689 get createTimer() {
4690 return _rootCreateTimer;
4691 }
4692 get createPeriodicTimer() {
4693 return _rootCreatePeriodicTimer;
4694 }
4695 get print() {
4696 return _rootPrint;
4697 }
4698 get fork() {
4699 return _rootFork;
4700 }
4701 }
4702 class _RootZone extends _Zone {
4703 _RootZone() {
4704 super._Zone();
4705 }
4706 get [_run]() {
4707 return new _ZoneFunction(_ROOT_ZONE, _rootRun);
4708 }
4709 get [_runUnary]() {
4710 return new _ZoneFunction(_ROOT_ZONE, _rootRunUnary);
4711 }
4712 get [_runBinary]() {
4713 return new _ZoneFunction(_ROOT_ZONE, _rootRunBinary);
4714 }
4715 get [_registerCallback]() {
4716 return new _ZoneFunction(_ROOT_ZONE, _rootRegisterCallback);
4717 }
4718 get [_registerUnaryCallback]() {
4719 return new _ZoneFunction(_ROOT_ZONE, _rootRegisterUnaryCallback);
4720 }
4721 get [_registerBinaryCallback]() {
4722 return new _ZoneFunction(_ROOT_ZONE, _rootRegisterBinaryCallback);
4723 }
4724 get [_errorCallback]() {
4725 return new _ZoneFunction(_ROOT_ZONE, _rootErrorCallback);
4726 }
4727 get [_scheduleMicrotask]() {
4728 return new _ZoneFunction(_ROOT_ZONE, _rootScheduleMicrotask);
4729 }
4730 get [_createTimer]() {
4731 return new _ZoneFunction(_ROOT_ZONE, _rootCreateTimer);
4732 }
4733 get [_createPeriodicTimer]() {
4734 return new _ZoneFunction(_ROOT_ZONE, _rootCreatePeriodicTimer);
4735 }
4736 get [_print]() {
4737 return new _ZoneFunction(_ROOT_ZONE, _rootPrint);
4738 }
4739 get [_fork]() {
4740 return new _ZoneFunction(_ROOT_ZONE, _rootFork);
4741 }
4742 get [_handleUncaughtError]() {
4743 return new _ZoneFunction(_ROOT_ZONE, _rootHandleUncaughtError);
4744 }
4745 get parent() {
4746 return null;
4747 }
4748 get [_map]() {
4749 return _rootMap;
4750 }
4751 get [_delegate]() {
4752 if (_rootDelegate !== null)
4753 return _rootDelegate;
4754 return _rootDelegate = new _ZoneDelegate(this);
4755 }
4756 get errorZone() {
4757 return this;
4758 }
4759 runGuarded(f) {
4760 try {
4761 if (core.identical(_ROOT_ZONE, Zone[_current])) {
4762 return f();
4763 }
4764 return _rootRun(null, null, this, f);
4765 } catch (e) {
4766 let s = dart.stackTrace(e);
4767 return this.handleUncaughtError(e, s);
4768 }
4769
4770 }
4771 runUnaryGuarded(f, arg) {
4772 try {
4773 if (core.identical(_ROOT_ZONE, Zone[_current])) {
4774 return dart.dinvokef(f, arg);
4775 }
4776 return _rootRunUnary(null, null, this, f, arg);
4777 } catch (e) {
4778 let s = dart.stackTrace(e);
4779 return this.handleUncaughtError(e, s);
4780 }
4781
4782 }
4783 runBinaryGuarded(f, arg1, arg2) {
4784 try {
4785 if (core.identical(_ROOT_ZONE, Zone[_current])) {
4786 return dart.dinvokef(f, arg1, arg2);
4787 }
4788 return _rootRunBinary(null, null, this, f, arg1, arg2);
4789 } catch (e) {
4790 let s = dart.stackTrace(e);
4791 return this.handleUncaughtError(e, s);
4792 }
4793
4794 }
4795 bindCallback(f, opt$) {
4796 let runGuarded = opt$.runGuarded === void 0 ? true : opt$.runGuarded;
4797 if (runGuarded) {
4798 return (() => this.runGuarded(f)).bind(this);
4799 } else {
4800 return (() => this.run(f)).bind(this);
4801 }
4802 }
4803 bindUnaryCallback(f, opt$) {
4804 let runGuarded = opt$.runGuarded === void 0 ? true : opt$.runGuarded;
4805 if (runGuarded) {
4806 return ((arg) => this.runUnaryGuarded(f, arg)).bind(this);
4807 } else {
4808 return ((arg) => this.runUnary(f, arg)).bind(this);
4809 }
4810 }
4811 bindBinaryCallback(f, opt$) {
4812 let runGuarded = opt$.runGuarded === void 0 ? true : opt$.runGuarded;
4813 if (runGuarded) {
4814 return ((arg1, arg2) => this.runBinaryGuarded(f, arg1, arg2)).bind(this) ;
4815 } else {
4816 return ((arg1, arg2) => this.runBinary(f, arg1, arg2)).bind(this);
4817 }
4818 }
4819 get(key) {
4820 return null;
4821 }
4822 handleUncaughtError(error, stackTrace) {
4823 return _rootHandleUncaughtError(null, null, this, error, stackTrace);
4824 }
4825 fork(opt$) {
4826 let specification = opt$.specification === void 0 ? null : opt$.specificat ion;
4827 let zoneValues = opt$.zoneValues === void 0 ? null : opt$.zoneValues;
4828 return _rootFork(null, null, this, specification, zoneValues);
4829 }
4830 run(f) {
4831 if (core.identical(Zone[_current], _ROOT_ZONE))
4832 return f();
4833 return _rootRun(null, null, this, f);
4834 }
4835 runUnary(f, arg) {
4836 if (core.identical(Zone[_current], _ROOT_ZONE))
4837 return dart.dinvokef(f, arg);
4838 return _rootRunUnary(null, null, this, f, arg);
4839 }
4840 runBinary(f, arg1, arg2) {
4841 if (core.identical(Zone[_current], _ROOT_ZONE))
4842 return dart.dinvokef(f, arg1, arg2);
4843 return _rootRunBinary(null, null, this, f, arg1, arg2);
4844 }
4845 registerCallback(f) {
4846 return f;
4847 }
4848 registerUnaryCallback(f) {
4849 return f;
4850 }
4851 registerBinaryCallback(f) {
4852 return f;
4853 }
4854 errorCallback(error, stackTrace) {
4855 return null;
4856 }
4857 scheduleMicrotask(f) {
4858 _rootScheduleMicrotask(null, null, this, f);
4859 }
4860 createTimer(duration, f) {
4861 return Timer._createTimer(duration, f);
4862 }
4863 createPeriodicTimer(duration, f) {
4864 return Timer._createPeriodicTimer(duration, f);
4865 }
4866 print(line) {
4867 _internal.printToConsole(line);
4868 }
4869 }
4870 _RootZone._rootDelegate = null;
4871 dart.defineLazyProperties(_RootZone, {
4872 get _rootMap() {
4873 return new collection.HashMap();
4874 },
4875 set _rootMap(_) {}
4876 });
4877 let _ROOT_ZONE = new _RootZone();
4878 // Function runZoned: (() → dynamic, {zoneValues: Map<dynamic, dynamic>, zoneS pecification: ZoneSpecification, onError: Function}) → dynamic
4879 function runZoned(body, opt$) {
4880 let zoneValues = opt$.zoneValues === void 0 ? null : opt$.zoneValues;
4881 let zoneSpecification = opt$.zoneSpecification === void 0 ? null : opt$.zone Specification;
4882 let onError = opt$.onError === void 0 ? null : opt$.onError;
4883 let errorHandler = null;
4884 if (onError !== null) {
4885 errorHandler = (self, parent, zone, error, stackTrace) => {
4886 try {
4887 if (dart.is(onError, ZoneBinaryCallback)) {
4888 return self.parent.runBinary(onError, error, stackTrace);
4889 }
4890 return self.parent.runUnary(dart.as(onError, dart.throw_("Unimplemente d type (dynamic) → dynamic")), error);
4891 } catch (e) {
4892 let s = dart.stackTrace(e);
4893 if (core.identical(e, error)) {
4894 return parent.handleUncaughtError(zone, error, stackTrace);
4895 } else {
4896 return parent.handleUncaughtError(zone, e, s);
4897 }
4898 }
4899
4900 };
4901 }
4902 if (zoneSpecification === null) {
4903 zoneSpecification = new ZoneSpecification({handleUncaughtError: errorHandl er});
4904 } else if (errorHandler !== null) {
4905 zoneSpecification = new ZoneSpecification.from(zoneSpecification, {handleU ncaughtError: errorHandler});
4906 }
4907 let zone = Zone.current.fork({specification: zoneSpecification, zoneValues: zoneValues});
4908 if (onError !== null) {
4909 return zone.runGuarded(body);
4910 } else {
4911 return zone.run(body);
4912 }
4913 }
4914 dart.copyProperties(exports, {
4915 get _hasDocument() {
4916 return dart.equals(typeof document, 'object');
4917 }
4918 });
4919 // Exports:
4920 exports.AsyncError = AsyncError;
4921 exports.Stream = Stream;
4922 exports.Stream$ = Stream$;
4923 exports.DeferredLibrary = DeferredLibrary;
4924 exports.DeferredLoadException = DeferredLoadException;
4925 exports.Future = Future;
4926 exports.Future$ = Future$;
4927 exports.TimeoutException = TimeoutException;
4928 exports.Completer = Completer;
4929 exports.Completer$ = Completer$;
4930 exports.scheduleMicrotask = scheduleMicrotask;
4931 exports.StreamSubscription = StreamSubscription;
4932 exports.StreamSubscription$ = StreamSubscription$;
4933 exports.EventSink = EventSink;
4934 exports.EventSink$ = EventSink$;
4935 exports.StreamView = StreamView;
4936 exports.StreamView$ = StreamView$;
4937 exports.StreamConsumer = StreamConsumer;
4938 exports.StreamConsumer$ = StreamConsumer$;
4939 exports.StreamSink = StreamSink;
4940 exports.StreamSink$ = StreamSink$;
4941 exports.StreamTransformer = StreamTransformer;
4942 exports.StreamTransformer$ = StreamTransformer$;
4943 exports.StreamIterator = StreamIterator;
4944 exports.StreamIterator$ = StreamIterator$;
4945 exports.StreamController = StreamController;
4946 exports.StreamController$ = StreamController$;
4947 exports.Timer = Timer;
4948 exports.ZoneSpecification = ZoneSpecification;
4949 exports.ZoneDelegate = ZoneDelegate;
4950 exports.Zone = Zone;
4951 exports.runZoned = runZoned;
4952 })(async || (async = {}));
OLDNEW
« lib/src/utils.dart ('K') | « test/codegen/expect/dart/_native_typed_data.js ('k') | test/codegen/expect/dart/collection.js » ('j') | test/generated_sdk/lib/core/function.dart » ('J')

Powered by Google App Engine
This is Rietveld 408576698