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

Issues Search
    My Issues | Starred     Open | Closed | All

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

Issue 1317933005: Some preliminary support for quasi-generics (Closed) Base URL: https://github.com/dart-lang/dev_compiler.git@master
Patch Set: Address comments Created 5 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « lib/runtime/dart/_native_typed_data.js ('k') | lib/runtime/dart/collection.js » ('j') | lib/src/checker/resolver.dart » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 dart_library.library('dart/async', null, /* Imports */[
2 "dart_runtime/dart",
3 'dart/core',
4 'dart/_internal',
5 'dart/collection'
6 ], /* Lazy imports */[
7 'dart/_isolate_helper'
8 ], function(exports, dart, core, _internal, collection, _isolate_helper) {
9 'use strict';
10 let dartx = dart.dartx;
11 function _invokeErrorHandler(errorHandler, error, stackTrace) {
12 if (dart.is(errorHandler, ZoneBinaryCallback)) {
13 return dart.dcall(errorHandler, error, stackTrace);
14 } else {
15 return dart.dcall(errorHandler, error);
16 }
17 }
18 dart.fn(_invokeErrorHandler, dart.dynamic, [core.Function, core.Object, core.S tackTrace]);
19 function _registerErrorHandler(errorHandler, zone) {
20 if (dart.is(errorHandler, ZoneBinaryCallback)) {
21 return zone.registerBinaryCallback(errorHandler);
22 } else {
23 return zone.registerUnaryCallback(dart.as(errorHandler, __CastType0));
24 }
25 }
26 dart.fn(_registerErrorHandler, () => dart.definiteFunctionType(core.Function, [core.Function, Zone]));
27 class AsyncError extends core.Object {
28 AsyncError(error, stackTrace) {
29 this.error = error;
30 this.stackTrace = stackTrace;
31 }
32 toString() {
33 return dart.toString(this.error);
34 }
35 }
36 AsyncError[dart.implements] = () => [core.Error];
37 dart.setSignature(AsyncError, {
38 constructors: () => ({AsyncError: [AsyncError, [dart.dynamic, core.StackTrac e]]})
39 });
40 class _UncaughtAsyncError extends AsyncError {
41 _UncaughtAsyncError(error, stackTrace) {
42 super.AsyncError(error, _UncaughtAsyncError._getBestStackTrace(error, stac kTrace));
43 }
44 static _getBestStackTrace(error, stackTrace) {
45 if (stackTrace != null)
46 return stackTrace;
47 if (dart.is(error, core.Error)) {
48 return dart.as(dart.dload(error, 'stackTrace'), core.StackTrace);
49 }
50 return null;
51 }
52 toString() {
53 let result = `Uncaught Error: ${this.error}`;
54 if (this.stackTrace != null) {
55 result = dart.notNull(result) + `\nStack Trace:\n${this.stackTrace}`;
56 }
57 return result;
58 }
59 }
60 dart.setSignature(_UncaughtAsyncError, {
61 constructors: () => ({_UncaughtAsyncError: [_UncaughtAsyncError, [dart.dynam ic, core.StackTrace]]}),
62 statics: () => ({_getBestStackTrace: [core.StackTrace, [dart.dynamic, core.S tackTrace]]}),
63 names: ['_getBestStackTrace']
64 });
65 let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(dart.dyn amic, [dart.dynamic]));
66 let _add = Symbol('_add');
67 let _closeUnchecked = Symbol('_closeUnchecked');
68 let _addError = Symbol('_addError');
69 let _completeError = Symbol('_completeError');
70 let _complete = Symbol('_complete');
71 let _sink = Symbol('_sink');
72 let Stream$ = dart.generic(function(T) {
73 class Stream extends core.Object {
74 Stream() {
75 }
76 static fromFuture(future) {
77 let controller = dart.as(StreamController$(T).new({sync: true}), _Stream Controller$(T));
78 future.then(dart.fn(value => {
79 controller[_add](dart.as(value, T));
80 controller[_closeUnchecked]();
81 }), {onError: dart.fn((error, stackTrace) => {
82 controller[_addError](error, dart.as(stackTrace, core.StackTrace));
83 controller[_closeUnchecked]();
84 })});
85 return controller.stream;
86 }
87 static fromIterable(data) {
88 return new (_GeneratedStreamImpl$(T))(dart.fn(() => new (_IterablePendin gEvents$(T))(data), _IterablePendingEvents$(T), []));
89 }
90 static periodic(period, computation) {
91 if (computation === void 0)
92 computation = null;
93 if (computation == null)
94 computation = dart.fn(i => null, dart.bottom, [dart.dynamic]);
95 let timer = null;
96 let computationCount = 0;
97 let controller = null;
98 let watch = new core.Stopwatch();
99 function sendEvent() {
100 watch.reset();
101 let data = computation((() => {
102 let x = computationCount;
103 computationCount = dart.notNull(x) + 1;
104 return x;
105 })());
106 controller.add(data);
107 }
108 dart.fn(sendEvent, dart.void, []);
109 function startPeriodicTimer() {
110 dart.assert(timer == null);
111 timer = Timer.periodic(period, dart.fn(timer => {
112 sendEvent();
113 }, dart.dynamic, [Timer]));
114 }
115 dart.fn(startPeriodicTimer, dart.void, []);
116 controller = StreamController$(T).new({sync: true, onListen: dart.fn(() => {
117 watch.start();
118 startPeriodicTimer();
119 }), onPause: dart.fn(() => {
120 timer.cancel();
121 timer = null;
122 watch.stop();
123 }), onResume: dart.fn(() => {
124 dart.assert(timer == null);
125 let elapsed = watch.elapsed;
126 watch.start();
127 timer = Timer.new(period['-'](elapsed), dart.fn(() => {
128 timer = null;
129 startPeriodicTimer();
130 sendEvent();
131 }));
132 }), onCancel: dart.fn(() => {
133 if (timer != null)
134 timer.cancel();
135 timer = null;
136 })});
137 return controller.stream;
138 }
139 static eventTransformed(source, mapSink) {
140 return new (_BoundSinkStream$(dart.dynamic, T))(source, dart.as(mapSink, _SinkMapper));
141 }
142 get isBroadcast() {
143 return false;
144 }
145 asBroadcastStream(opts) {
146 let onListen = opts && 'onListen' in opts ? opts.onListen : null;
147 dart.as(onListen, dart.functionType(dart.void, [StreamSubscription$(T)]) );
148 let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
149 dart.as(onCancel, dart.functionType(dart.void, [StreamSubscription$(T)]) );
150 return new (_AsBroadcastStream$(T))(this, dart.as(onListen, __CastType12 ), dart.as(onCancel, dart.functionType(dart.void, [StreamSubscription])));
151 }
152 where(test) {
153 dart.as(test, dart.functionType(core.bool, [T]));
154 return new (_WhereStream$(T))(this, test);
155 }
156 map(convert) {
157 dart.as(convert, dart.functionType(dart.dynamic, [T]));
158 return new (_MapStream$(T, dart.dynamic))(this, convert);
159 }
160 asyncMap(convert) {
161 dart.as(convert, dart.functionType(dart.dynamic, [T]));
162 let controller = null;
163 let subscription = null;
164 let onListen = (function() {
165 let add = dart.bind(controller, 'add');
166 dart.assert(dart.is(controller, _StreamController) || dart.is(controll er, _BroadcastStreamController));
167 let eventSink = controller;
168 let addError = eventSink[_addError];
169 subscription = this.listen(dart.fn(event => {
170 dart.as(event, T);
171 let newValue = null;
172 try {
173 newValue = convert(event);
174 } catch (e) {
175 let s = dart.stackTrace(e);
176 controller.addError(e, s);
177 return;
178 }
179
180 if (dart.is(newValue, Future)) {
181 subscription.pause();
182 dart.dsend(dart.dsend(newValue, 'then', add, {onError: addError}), 'whenComplete', dart.bind(subscription, 'resume'));
183 } else {
184 controller.add(newValue);
185 }
186 }, dart.dynamic, [T]), {onError: dart.as(addError, core.Function), onD one: dart.bind(controller, 'close')});
187 }).bind(this);
188 dart.fn(onListen, dart.void, []);
189 if (dart.notNull(this.isBroadcast)) {
190 controller = StreamController.broadcast({onListen: onListen, onCancel: dart.fn(() => {
191 subscription.cancel();
192 }), sync: true});
193 } else {
194 controller = StreamController.new({onListen: onListen, onPause: dart.f n(() => {
195 subscription.pause();
196 }), onResume: dart.fn(() => {
197 subscription.resume();
198 }), onCancel: dart.fn(() => {
199 subscription.cancel();
200 }), sync: true});
201 }
202 return controller.stream;
203 }
204 asyncExpand(convert) {
205 dart.as(convert, dart.functionType(Stream$(), [T]));
206 let controller = null;
207 let subscription = null;
208 let onListen = (function() {
209 dart.assert(dart.is(controller, _StreamController) || dart.is(controll er, _BroadcastStreamController));
210 let eventSink = controller;
211 subscription = this.listen(dart.fn(event => {
212 dart.as(event, T);
213 let newStream = null;
214 try {
215 newStream = convert(event);
216 } catch (e) {
217 let s = dart.stackTrace(e);
218 controller.addError(e, s);
219 return;
220 }
221
222 if (newStream != null) {
223 subscription.pause();
224 controller.addStream(newStream).whenComplete(dart.bind(subscriptio n, 'resume'));
225 }
226 }, dart.dynamic, [T]), {onError: dart.as(eventSink[_addError], core.Fu nction), onDone: dart.bind(controller, 'close')});
227 }).bind(this);
228 dart.fn(onListen, dart.void, []);
229 if (dart.notNull(this.isBroadcast)) {
230 controller = StreamController.broadcast({onListen: onListen, onCancel: dart.fn(() => {
231 subscription.cancel();
232 }), sync: true});
233 } else {
234 controller = StreamController.new({onListen: onListen, onPause: dart.f n(() => {
235 subscription.pause();
236 }), onResume: dart.fn(() => {
237 subscription.resume();
238 }), onCancel: dart.fn(() => {
239 subscription.cancel();
240 }), sync: true});
241 }
242 return controller.stream;
243 }
244 handleError(onError, opts) {
245 let test = opts && 'test' in opts ? opts.test : null;
246 dart.as(test, dart.functionType(core.bool, [dart.dynamic]));
247 return new (_HandleErrorStream$(T))(this, onError, test);
248 }
249 expand(convert) {
250 dart.as(convert, dart.functionType(core.Iterable, [T]));
251 return new (_ExpandStream$(T, dart.dynamic))(this, convert);
252 }
253 pipe(streamConsumer) {
254 dart.as(streamConsumer, StreamConsumer$(T));
255 return streamConsumer.addStream(this).then(dart.fn(_ => streamConsumer.c lose(), Future, [dart.dynamic]));
256 }
257 transform(streamTransformer) {
258 dart.as(streamTransformer, StreamTransformer$(T, dart.dynamic));
259 return streamTransformer.bind(this);
260 }
261 reduce(combine) {
262 dart.as(combine, dart.functionType(T, [T, T]));
263 let result = new (_Future$(T))();
264 let seenFirst = false;
265 let value = null;
266 let subscription = null;
267 subscription = this.listen(dart.fn(element => {
268 dart.as(element, T);
269 if (dart.notNull(seenFirst)) {
270 _runUserCode(dart.fn(() => combine(value, element), T, []), dart.fn( newValue => {
271 dart.as(newValue, T);
272 value = newValue;
273 }, dart.dynamic, [T]), dart.as(_cancelAndErrorClosure(subscription, result), __CastType14));
274 } else {
275 value = element;
276 seenFirst = true;
277 }
278 }, dart.dynamic, [T]), {onError: dart.bind(result, _completeError), onDo ne: dart.fn(() => {
279 if (!dart.notNull(seenFirst)) {
280 try {
281 dart.throw(_internal.IterableElementError.noElement());
282 } catch (e) {
283 let s = dart.stackTrace(e);
284 _completeWithErrorCallback(result, e, s);
285 }
286
287 } else {
288 result[_complete](value);
289 }
290 }), cancelOnError: true});
291 return result;
292 }
293 fold(initialValue, combine) {
294 dart.as(combine, dart.functionType(dart.dynamic, [dart.dynamic, T]));
295 let result = new _Future();
296 let value = initialValue;
297 let subscription = null;
298 subscription = this.listen(dart.fn(element => {
299 dart.as(element, T);
300 _runUserCode(dart.fn(() => dart.dcall(combine, value, element)), dart. fn(newValue => {
301 value = newValue;
302 }), dart.as(_cancelAndErrorClosure(subscription, result), dart.functio nType(dart.dynamic, [dart.dynamic, core.StackTrace])));
303 }, dart.dynamic, [T]), {onError: dart.fn((e, st) => {
304 result[_completeError](e, dart.as(st, core.StackTrace));
305 }), onDone: dart.fn(() => {
306 result[_complete](value);
307 }), cancelOnError: true});
308 return result;
309 }
310 join(separator) {
311 if (separator === void 0)
312 separator = "";
313 let result = new (_Future$(core.String))();
314 let buffer = new core.StringBuffer();
315 let subscription = null;
316 let first = true;
317 subscription = this.listen(dart.fn(element => {
318 dart.as(element, T);
319 if (!dart.notNull(first)) {
320 buffer.write(separator);
321 }
322 first = false;
323 try {
324 buffer.write(element);
325 } catch (e) {
326 let s = dart.stackTrace(e);
327 _cancelAndErrorWithReplacement(subscription, result, e, s);
328 }
329
330 }, dart.dynamic, [T]), {onError: dart.fn(e => {
331 result[_completeError](e);
332 }), onDone: dart.fn(() => {
333 result[_complete](dart.toString(buffer));
334 }), cancelOnError: true});
335 return result;
336 }
337 contains(needle) {
338 let future = new (_Future$(core.bool))();
339 let subscription = null;
340 subscription = this.listen(dart.fn(element => {
341 dart.as(element, T);
342 _runUserCode(dart.fn(() => dart.equals(element, needle), core.bool, [] ), dart.fn(isMatch => {
343 if (dart.notNull(isMatch)) {
344 _cancelAndValue(subscription, future, true);
345 }
346 }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscrip tion, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])) );
347 }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDo ne: dart.fn(() => {
348 future[_complete](false);
349 }), cancelOnError: true});
350 return future;
351 }
352 forEach(action) {
353 dart.as(action, dart.functionType(dart.void, [T]));
354 let future = new _Future();
355 let subscription = null;
356 subscription = this.listen(dart.fn(element => {
357 dart.as(element, T);
358 _runUserCode(dart.fn(() => action(element), dart.void, []), dart.fn(_ => {
359 }), dart.as(_cancelAndErrorClosure(subscription, future), dart.functio nType(dart.dynamic, [dart.dynamic, core.StackTrace])));
360 }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDo ne: dart.fn(() => {
361 future[_complete](null);
362 }), cancelOnError: true});
363 return future;
364 }
365 every(test) {
366 dart.as(test, dart.functionType(core.bool, [T]));
367 let future = new (_Future$(core.bool))();
368 let subscription = null;
369 subscription = this.listen(dart.fn(element => {
370 dart.as(element, T);
371 _runUserCode(dart.fn(() => test(element), core.bool, []), dart.fn(isMa tch => {
372 if (!dart.notNull(isMatch)) {
373 _cancelAndValue(subscription, future, false);
374 }
375 }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscrip tion, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])) );
376 }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDo ne: dart.fn(() => {
377 future[_complete](true);
378 }), cancelOnError: true});
379 return future;
380 }
381 any(test) {
382 dart.as(test, dart.functionType(core.bool, [T]));
383 let future = new (_Future$(core.bool))();
384 let subscription = null;
385 subscription = this.listen(dart.fn(element => {
386 dart.as(element, T);
387 _runUserCode(dart.fn(() => test(element), core.bool, []), dart.fn(isMa tch => {
388 if (dart.notNull(isMatch)) {
389 _cancelAndValue(subscription, future, true);
390 }
391 }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscrip tion, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])) );
392 }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDo ne: dart.fn(() => {
393 future[_complete](false);
394 }), cancelOnError: true});
395 return future;
396 }
397 get length() {
398 let future = new (_Future$(core.int))();
399 let count = 0;
400 this.listen(dart.fn(_ => {
401 count = dart.notNull(count) + 1;
402 }), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
403 future[_complete](count);
404 }), cancelOnError: true});
405 return future;
406 }
407 get isEmpty() {
408 let future = new (_Future$(core.bool))();
409 let subscription = null;
410 subscription = this.listen(dart.fn(_ => {
411 _cancelAndValue(subscription, future, false);
412 }), {onError: dart.bind(future, _completeError), onDone: dart.fn(() => {
413 future[_complete](true);
414 }), cancelOnError: true});
415 return future;
416 }
417 toList() {
418 let result = dart.list([], T);
419 let future = new (_Future$(core.List$(T)))();
420 this.listen(dart.fn(data => {
421 dart.as(data, T);
422 result[dartx.add](data);
423 }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDo ne: dart.fn(() => {
424 future[_complete](result);
425 }), cancelOnError: true});
426 return future;
427 }
428 toSet() {
429 let result = core.Set$(T).new();
430 let future = new (_Future$(core.Set$(T)))();
431 this.listen(dart.fn(data => {
432 dart.as(data, T);
433 result.add(data);
434 }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDo ne: dart.fn(() => {
435 future[_complete](result);
436 }), cancelOnError: true});
437 return future;
438 }
439 drain(futureValue) {
440 if (futureValue === void 0)
441 futureValue = null;
442 return this.listen(null, {cancelOnError: true}).asFuture(futureValue);
443 }
444 take(count) {
445 return new (_TakeStream$(T))(this, count);
446 }
447 takeWhile(test) {
448 dart.as(test, dart.functionType(core.bool, [T]));
449 return new (_TakeWhileStream$(T))(this, test);
450 }
451 skip(count) {
452 return new (_SkipStream$(T))(this, count);
453 }
454 skipWhile(test) {
455 dart.as(test, dart.functionType(core.bool, [T]));
456 return new (_SkipWhileStream$(T))(this, test);
457 }
458 distinct(equals) {
459 if (equals === void 0)
460 equals = null;
461 dart.as(equals, dart.functionType(core.bool, [T, T]));
462 return new (_DistinctStream$(T))(this, equals);
463 }
464 get first() {
465 let future = new (_Future$(T))();
466 let subscription = null;
467 subscription = this.listen(dart.fn(value => {
468 dart.as(value, T);
469 _cancelAndValue(subscription, future, value);
470 }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDo ne: dart.fn(() => {
471 try {
472 dart.throw(_internal.IterableElementError.noElement());
473 } catch (e) {
474 let s = dart.stackTrace(e);
475 _completeWithErrorCallback(future, e, s);
476 }
477
478 }), cancelOnError: true});
479 return future;
480 }
481 get last() {
482 let future = new (_Future$(T))();
483 let result = null;
484 let foundResult = false;
485 let subscription = null;
486 subscription = this.listen(dart.fn(value => {
487 dart.as(value, T);
488 foundResult = true;
489 result = value;
490 }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDo ne: dart.fn(() => {
491 if (dart.notNull(foundResult)) {
492 future[_complete](result);
493 return;
494 }
495 try {
496 dart.throw(_internal.IterableElementError.noElement());
497 } catch (e) {
498 let s = dart.stackTrace(e);
499 _completeWithErrorCallback(future, e, s);
500 }
501
502 }), cancelOnError: true});
503 return future;
504 }
505 get single() {
506 let future = new (_Future$(T))();
507 let result = null;
508 let foundResult = false;
509 let subscription = null;
510 subscription = this.listen(dart.fn(value => {
511 dart.as(value, T);
512 if (dart.notNull(foundResult)) {
513 try {
514 dart.throw(_internal.IterableElementError.tooMany());
515 } catch (e) {
516 let s = dart.stackTrace(e);
517 _cancelAndErrorWithReplacement(subscription, future, e, s);
518 }
519
520 return;
521 }
522 foundResult = true;
523 result = value;
524 }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDo ne: dart.fn(() => {
525 if (dart.notNull(foundResult)) {
526 future[_complete](result);
527 return;
528 }
529 try {
530 dart.throw(_internal.IterableElementError.noElement());
531 } catch (e) {
532 let s = dart.stackTrace(e);
533 _completeWithErrorCallback(future, e, s);
534 }
535
536 }), cancelOnError: true});
537 return future;
538 }
539 firstWhere(test, opts) {
540 dart.as(test, dart.functionType(core.bool, [T]));
541 let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
542 dart.as(defaultValue, dart.functionType(core.Object, []));
543 let future = new _Future();
544 let subscription = null;
545 subscription = this.listen(dart.fn(value => {
546 dart.as(value, T);
547 _runUserCode(dart.fn(() => test(value), core.bool, []), dart.fn(isMatc h => {
548 if (dart.notNull(isMatch)) {
549 _cancelAndValue(subscription, future, value);
550 }
551 }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscrip tion, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])) );
552 }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDo ne: dart.fn(() => {
553 if (defaultValue != null) {
554 _runUserCode(defaultValue, dart.bind(future, _complete), dart.bind (future, _completeError));
555 return;
556 }
557 try {
558 dart.throw(_internal.IterableElementError.noElement());
559 } catch (e) {
560 let s = dart.stackTrace(e);
561 _completeWithErrorCallback(future, e, s);
562 }
563
564 }), cancelOnError: true});
565 return future;
566 }
567 lastWhere(test, opts) {
568 dart.as(test, dart.functionType(core.bool, [T]));
569 let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
570 dart.as(defaultValue, dart.functionType(core.Object, []));
571 let future = new _Future();
572 let result = null;
573 let foundResult = false;
574 let subscription = null;
575 subscription = this.listen(dart.fn(value => {
576 dart.as(value, T);
577 _runUserCode(dart.fn(() => true == test(value), core.bool, []), dart.f n(isMatch => {
578 if (dart.notNull(isMatch)) {
579 foundResult = true;
580 result = value;
581 }
582 }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscrip tion, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])) );
583 }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDo ne: dart.fn(() => {
584 if (dart.notNull(foundResult)) {
585 future[_complete](result);
586 return;
587 }
588 if (defaultValue != null) {
589 _runUserCode(defaultValue, dart.bind(future, _complete), dart.bind (future, _completeError));
590 return;
591 }
592 try {
593 dart.throw(_internal.IterableElementError.noElement());
594 } catch (e) {
595 let s = dart.stackTrace(e);
596 _completeWithErrorCallback(future, e, s);
597 }
598
599 }), cancelOnError: true});
600 return future;
601 }
602 singleWhere(test) {
603 dart.as(test, dart.functionType(core.bool, [T]));
604 let future = new (_Future$(T))();
605 let result = null;
606 let foundResult = false;
607 let subscription = null;
608 subscription = this.listen(dart.fn(value => {
609 dart.as(value, T);
610 _runUserCode(dart.fn(() => true == test(value), core.bool, []), dart.f n(isMatch => {
611 if (dart.notNull(isMatch)) {
612 if (dart.notNull(foundResult)) {
613 try {
614 dart.throw(_internal.IterableElementError.tooMany());
615 } catch (e) {
616 let s = dart.stackTrace(e);
617 _cancelAndErrorWithReplacement(subscription, future, e, s);
618 }
619
620 return;
621 }
622 foundResult = true;
623 result = value;
624 }
625 }, dart.dynamic, [core.bool]), dart.as(_cancelAndErrorClosure(subscrip tion, future), dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace])) );
626 }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDo ne: dart.fn(() => {
627 if (dart.notNull(foundResult)) {
628 future[_complete](result);
629 return;
630 }
631 try {
632 dart.throw(_internal.IterableElementError.noElement());
633 } catch (e) {
634 let s = dart.stackTrace(e);
635 _completeWithErrorCallback(future, e, s);
636 }
637
638 }), cancelOnError: true});
639 return future;
640 }
641 elementAt(index) {
642 if (!(typeof index == 'number') || dart.notNull(index) < 0)
643 dart.throw(new core.ArgumentError(index));
644 let future = new (_Future$(T))();
645 let subscription = null;
646 let elementIndex = 0;
647 subscription = this.listen(dart.fn(value => {
648 dart.as(value, T);
649 if (index == elementIndex) {
650 _cancelAndValue(subscription, future, value);
651 return;
652 }
653 elementIndex = dart.notNull(elementIndex) + 1;
654 }, dart.dynamic, [T]), {onError: dart.bind(future, _completeError), onDo ne: dart.fn((() => {
655 future[_completeError](core.RangeError.index(index, this, "index", n ull, elementIndex));
656 }).bind(this)), cancelOnError: true});
657 return future;
658 }
659 timeout(timeLimit, opts) {
660 let onTimeout = opts && 'onTimeout' in opts ? opts.onTimeout : null;
661 dart.as(onTimeout, dart.functionType(dart.void, [EventSink]));
662 let controller = null;
663 let subscription = null;
664 let timer = null;
665 let zone = null;
666 let timeout = null;
667 function onData(event) {
668 dart.as(event, T);
669 timer.cancel();
670 controller.add(event);
671 timer = zone.createTimer(timeLimit, dart.as(timeout, __CastType17));
672 }
673 dart.fn(onData, dart.void, [T]);
674 function onError(error, stackTrace) {
675 timer.cancel();
676 dart.assert(dart.is(controller, _StreamController) || dart.is(controll er, _BroadcastStreamController));
677 let eventSink = controller;
678 dart.dcall(eventSink[_addError], error, stackTrace);
679 timer = zone.createTimer(timeLimit, dart.as(timeout, dart.functionType (dart.void, [])));
680 }
681 dart.fn(onError, dart.void, [dart.dynamic, core.StackTrace]);
682 function onDone() {
683 timer.cancel();
684 controller.close();
685 }
686 dart.fn(onDone, dart.void, []);
687 let onListen = (function() {
688 zone = Zone.current;
689 if (onTimeout == null) {
690 timeout = dart.fn(() => {
691 controller.addError(new TimeoutException("No stream event", timeLi mit), null);
692 });
693 } else {
694 onTimeout = dart.as(zone.registerUnaryCallback(onTimeout), __CastTyp e18);
695 let wrapper = new _ControllerEventSinkWrapper(null);
696 timeout = dart.fn(() => {
697 wrapper[_sink] = controller;
698 zone.runUnaryGuarded(onTimeout, wrapper);
699 wrapper[_sink] = null;
700 });
701 }
702 subscription = this.listen(onData, {onError: onError, onDone: onDone}) ;
703 timer = zone.createTimer(timeLimit, dart.as(timeout, dart.functionType (dart.void, [])));
704 }).bind(this);
705 dart.fn(onListen, dart.void, []);
706 function onCancel() {
707 timer.cancel();
708 let result = subscription.cancel();
709 subscription = null;
710 return result;
711 }
712 dart.fn(onCancel, Future, []);
713 controller = dart.notNull(this.isBroadcast) ? new _SyncBroadcastStreamCo ntroller(onListen, onCancel) : new _SyncStreamController(onListen, dart.fn(() => {
714 timer.cancel();
715 subscription.pause();
716 }), dart.fn(() => {
717 subscription.resume();
718 timer = zone.createTimer(timeLimit, dart.as(timeout, dart.functionType (dart.void, [])));
719 }), onCancel);
720 return controller.stream;
721 }
722 }
723 dart.setSignature(Stream, {
724 constructors: () => ({
725 Stream: [Stream$(T), []],
726 fromFuture: [Stream$(T), [Future$(T)]],
727 fromIterable: [Stream$(T), [core.Iterable$(T)]],
728 periodic: [Stream$(T), [core.Duration], [dart.functionType(T, [core.int] )]],
729 eventTransformed: [Stream$(T), [Stream$(), dart.functionType(EventSink, [EventSink$(T)])]]
730 }),
731 methods: () => ({
732 asBroadcastStream: [Stream$(T), [], {onListen: dart.functionType(dart.vo id, [StreamSubscription$(T)]), onCancel: dart.functionType(dart.void, [StreamSub scription$(T)])}],
733 where: [Stream$(T), [dart.functionType(core.bool, [T])]],
734 map: [Stream$(), [dart.functionType(dart.dynamic, [T])]],
735 asyncMap: [Stream$(), [dart.functionType(dart.dynamic, [T])]],
736 asyncExpand: [Stream$(), [dart.functionType(Stream$(), [T])]],
737 handleError: [Stream$(T), [core.Function], {test: dart.functionType(core .bool, [dart.dynamic])}],
738 expand: [Stream$(), [dart.functionType(core.Iterable, [T])]],
739 pipe: [Future, [StreamConsumer$(T)]],
740 transform: [Stream$(), [StreamTransformer$(T, dart.dynamic)]],
741 reduce: [Future$(T), [dart.functionType(T, [T, T])]],
742 fold: [Future, [dart.dynamic, dart.functionType(dart.dynamic, [dart.dyna mic, T])]],
743 join: [Future$(core.String), [], [core.String]],
744 contains: [Future$(core.bool), [core.Object]],
745 forEach: [Future, [dart.functionType(dart.void, [T])]],
746 every: [Future$(core.bool), [dart.functionType(core.bool, [T])]],
747 any: [Future$(core.bool), [dart.functionType(core.bool, [T])]],
748 toList: [Future$(core.List$(T)), []],
749 toSet: [Future$(core.Set$(T)), []],
750 drain: [Future, [], [dart.dynamic]],
751 take: [Stream$(T), [core.int]],
752 takeWhile: [Stream$(T), [dart.functionType(core.bool, [T])]],
753 skip: [Stream$(T), [core.int]],
754 skipWhile: [Stream$(T), [dart.functionType(core.bool, [T])]],
755 distinct: [Stream$(T), [], [dart.functionType(core.bool, [T, T])]],
756 firstWhere: [Future, [dart.functionType(core.bool, [T])], {defaultValue: dart.functionType(core.Object, [])}],
757 lastWhere: [Future, [dart.functionType(core.bool, [T])], {defaultValue: dart.functionType(core.Object, [])}],
758 singleWhere: [Future$(T), [dart.functionType(core.bool, [T])]],
759 elementAt: [Future$(T), [core.int]],
760 timeout: [Stream$(), [core.Duration], {onTimeout: dart.functionType(dart .void, [EventSink])}]
761 })
762 });
763 return Stream;
764 });
765 let Stream = Stream$();
766 let _createSubscription = Symbol('_createSubscription');
767 let _onListen = Symbol('_onListen');
768 let _StreamImpl$ = dart.generic(function(T) {
769 class _StreamImpl extends Stream$(T) {
770 _StreamImpl() {
771 super.Stream();
772 }
773 listen(onData, opts) {
774 dart.as(onData, dart.functionType(dart.void, [T]));
775 let onError = opts && 'onError' in opts ? opts.onError : null;
776 let onDone = opts && 'onDone' in opts ? opts.onDone : null;
777 dart.as(onDone, dart.functionType(dart.void, []));
778 let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
779 cancelOnError = core.identical(true, cancelOnError);
780 let subscription = this[_createSubscription](onData, onError, onDone, ca ncelOnError);
781 this[_onListen](subscription);
782 return dart.as(subscription, StreamSubscription$(T));
783 }
784 [_createSubscription](onData, onError, onDone, cancelOnError) {
785 dart.as(onData, dart.functionType(dart.void, [T]));
786 dart.as(onDone, dart.functionType(dart.void, []));
787 return new (_BufferingStreamSubscription$(T))(onData, onError, onDone, c ancelOnError);
788 }
789 [_onListen](subscription) {}
790 }
791 dart.setSignature(_StreamImpl, {
792 methods: () => ({
793 listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {o nError: core.Function, onDone: dart.functionType(dart.void, []), cancelOnError: core.bool}],
794 [_createSubscription]: [StreamSubscription$(T), [dart.functionType(dart. void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]],
795 [_onListen]: [dart.void, [StreamSubscription]]
796 })
797 });
798 return _StreamImpl;
799 });
800 let _StreamImpl = _StreamImpl$();
801 let _controller = Symbol('_controller');
802 let _subscribe = Symbol('_subscribe');
803 let _ControllerStream$ = dart.generic(function(T) {
804 class _ControllerStream extends _StreamImpl$(T) {
805 _ControllerStream(controller) {
806 this[_controller] = controller;
807 }
808 [_createSubscription](onData, onError, onDone, cancelOnError) {
809 dart.as(onData, dart.functionType(dart.void, [T]));
810 dart.as(onDone, dart.functionType(dart.void, []));
811 return this[_controller][_subscribe](onData, onError, onDone, cancelOnEr ror);
812 }
813 get hashCode() {
814 return dart.notNull(dart.hashCode(this[_controller])) ^ 892482866;
815 }
816 ['=='](other) {
817 if (dart.notNull(core.identical(this, other)))
818 return true;
819 if (!dart.is(other, _ControllerStream$()))
820 return false;
821 let otherStream = dart.as(other, _ControllerStream$());
822 return core.identical(otherStream[_controller], this[_controller]);
823 }
824 }
825 dart.setSignature(_ControllerStream, {
826 constructors: () => ({_ControllerStream: [_ControllerStream$(T), [_StreamC ontrollerLifecycle$(T)]]}),
827 methods: () => ({
828 [_createSubscription]: [StreamSubscription$(T), [dart.functionType(dart. void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]],
829 '==': [core.bool, [core.Object]]
830 })
831 });
832 return _ControllerStream;
833 });
834 let _ControllerStream = _ControllerStream$();
835 let _BroadcastStream$ = dart.generic(function(T) {
836 class _BroadcastStream extends _ControllerStream$(T) {
837 _BroadcastStream(controller) {
838 super._ControllerStream(dart.as(controller, _StreamControllerLifecycle$( T)));
839 }
840 get isBroadcast() {
841 return true;
842 }
843 }
844 dart.setSignature(_BroadcastStream, {
845 constructors: () => ({_BroadcastStream: [_BroadcastStream$(T), [_StreamCon trollerLifecycle]]})
846 });
847 return _BroadcastStream;
848 });
849 let _BroadcastStream = _BroadcastStream$();
850 let _next = Symbol('_next');
851 let _previous = Symbol('_previous');
852 class _BroadcastSubscriptionLink extends core.Object {
853 _BroadcastSubscriptionLink() {
854 this[_next] = null;
855 this[_previous] = null;
856 }
857 }
858 let _zone = Symbol('_zone');
859 let _state = Symbol('_state');
860 let _onData = Symbol('_onData');
861 let _onError = Symbol('_onError');
862 let _onDone = Symbol('_onDone');
863 let _cancelFuture = Symbol('_cancelFuture');
864 let _pending = Symbol('_pending');
865 let _setPendingEvents = Symbol('_setPendingEvents');
866 let _isCanceled = Symbol('_isCanceled');
867 let _extractPending = Symbol('_extractPending');
868 let _isPaused = Symbol('_isPaused');
869 let _isInputPaused = Symbol('_isInputPaused');
870 let _inCallback = Symbol('_inCallback');
871 let _guardCallback = Symbol('_guardCallback');
872 let _onPause = Symbol('_onPause');
873 let _decrementPauseCount = Symbol('_decrementPauseCount');
874 let _hasPending = Symbol('_hasPending');
875 let _mayResumeInput = Symbol('_mayResumeInput');
876 let _onResume = Symbol('_onResume');
877 let _cancel = Symbol('_cancel');
878 let _isClosed = Symbol('_isClosed');
879 let _waitsForCancel = Symbol('_waitsForCancel');
880 let _canFire = Symbol('_canFire');
881 let _cancelOnError = Symbol('_cancelOnError');
882 let _onCancel = Symbol('_onCancel');
883 let _incrementPauseCount = Symbol('_incrementPauseCount');
884 let _sendData = Symbol('_sendData');
885 let _addPending = Symbol('_addPending');
886 let _sendError = Symbol('_sendError');
887 let _sendDone = Symbol('_sendDone');
888 let _close = Symbol('_close');
889 let _checkState = Symbol('_checkState');
890 let _BufferingStreamSubscription$ = dart.generic(function(T) {
891 class _BufferingStreamSubscription extends core.Object {
892 _BufferingStreamSubscription(onData, onError, onDone, cancelOnError) {
893 this[_zone] = Zone.current;
894 this[_state] = dart.notNull(cancelOnError) ? _BufferingStreamSubscriptio n$()._STATE_CANCEL_ON_ERROR : 0;
895 this[_onData] = null;
896 this[_onError] = null;
897 this[_onDone] = null;
898 this[_cancelFuture] = null;
899 this[_pending] = null;
900 this.onData(onData);
901 this.onError(onError);
902 this.onDone(onDone);
903 }
904 [_setPendingEvents](pendingEvents) {
905 dart.assert(this[_pending] == null);
906 if (pendingEvents == null)
907 return;
908 this[_pending] = pendingEvents;
909 if (!dart.notNull(pendingEvents.isEmpty)) {
910 this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStr eamSubscription$()._STATE_HAS_PENDING);
911 this[_pending].schedule(this);
912 }
913 }
914 [_extractPending]() {
915 dart.assert(this[_isCanceled]);
916 let events = this[_pending];
917 this[_pending] = null;
918 return events;
919 }
920 onData(handleData) {
921 dart.as(handleData, dart.functionType(dart.void, [T]));
922 if (handleData == null)
923 handleData = dart.as(_nullDataHandler, __CastType20);
924 this[_onData] = dart.as(this[_zone].registerUnaryCallback(handleData), _ DataHandler$(T));
925 }
926 onError(handleError) {
927 if (handleError == null)
928 handleError = _nullErrorHandler;
929 this[_onError] = _registerErrorHandler(handleError, this[_zone]);
930 }
931 onDone(handleDone) {
932 dart.as(handleDone, dart.functionType(dart.void, []));
933 if (handleDone == null)
934 handleDone = _nullDoneHandler;
935 this[_onDone] = this[_zone].registerCallback(handleDone);
936 }
937 pause(resumeSignal) {
938 if (resumeSignal === void 0)
939 resumeSignal = null;
940 if (dart.notNull(this[_isCanceled]))
941 return;
942 let wasPaused = this[_isPaused];
943 let wasInputPaused = this[_isInputPaused];
944 this[_state] = dart.notNull(this[_state]) + dart.notNull(_BufferingStrea mSubscription$()._STATE_PAUSE_COUNT) | dart.notNull(_BufferingStreamSubscription $()._STATE_INPUT_PAUSED);
945 if (resumeSignal != null)
946 resumeSignal.whenComplete(dart.bind(this, 'resume'));
947 if (!dart.notNull(wasPaused) && this[_pending] != null)
948 this[_pending].cancelSchedule();
949 if (!dart.notNull(wasInputPaused) && !dart.notNull(this[_inCallback]))
950 this[_guardCallback](dart.bind(this, _onPause));
951 }
952 resume() {
953 if (dart.notNull(this[_isCanceled]))
954 return;
955 if (dart.notNull(this[_isPaused])) {
956 this[_decrementPauseCount]();
957 if (!dart.notNull(this[_isPaused])) {
958 if (dart.notNull(this[_hasPending]) && !dart.notNull(this[_pending]. isEmpty)) {
959 this[_pending].schedule(this);
960 } else {
961 dart.assert(this[_mayResumeInput]);
962 this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_Bufferi ngStreamSubscription$()._STATE_INPUT_PAUSED);
963 if (!dart.notNull(this[_inCallback]))
964 this[_guardCallback](dart.bind(this, _onResume));
965 }
966 }
967 }
968 }
969 cancel() {
970 this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStre amSubscription$()._STATE_WAIT_FOR_CANCEL);
971 if (dart.notNull(this[_isCanceled]))
972 return this[_cancelFuture];
973 this[_cancel]();
974 return this[_cancelFuture];
975 }
976 asFuture(futureValue) {
977 if (futureValue === void 0)
978 futureValue = null;
979 let result = new (_Future$(T))();
980 this[_onDone] = dart.fn(() => {
981 result[_complete](futureValue);
982 });
983 this[_onError] = dart.fn(((error, stackTrace) => {
984 this.cancel();
985 result[_completeError](error, dart.as(stackTrace, core.StackTrace));
986 }).bind(this));
987 return result;
988 }
989 get [_isInputPaused]() {
990 return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscr iption$()._STATE_INPUT_PAUSED)) != 0;
991 }
992 get [_isClosed]() {
993 return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscr iption$()._STATE_CLOSED)) != 0;
994 }
995 get [_isCanceled]() {
996 return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscr iption$()._STATE_CANCELED)) != 0;
997 }
998 get [_waitsForCancel]() {
999 return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscr iption$()._STATE_WAIT_FOR_CANCEL)) != 0;
1000 }
1001 get [_inCallback]() {
1002 return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscr iption$()._STATE_IN_CALLBACK)) != 0;
1003 }
1004 get [_hasPending]() {
1005 return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscr iption$()._STATE_HAS_PENDING)) != 0;
1006 }
1007 get [_isPaused]() {
1008 return dart.notNull(this[_state]) >= dart.notNull(_BufferingStreamSubscr iption$()._STATE_PAUSE_COUNT);
1009 }
1010 get [_canFire]() {
1011 return dart.notNull(this[_state]) < dart.notNull(_BufferingStreamSubscri ption$()._STATE_IN_CALLBACK);
1012 }
1013 get [_mayResumeInput]() {
1014 return !dart.notNull(this[_isPaused]) && (this[_pending] == null || dart .notNull(this[_pending].isEmpty));
1015 }
1016 get [_cancelOnError]() {
1017 return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscr iption$()._STATE_CANCEL_ON_ERROR)) != 0;
1018 }
1019 get isPaused() {
1020 return this[_isPaused];
1021 }
1022 [_cancel]() {
1023 this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStrea mSubscription$()._STATE_CANCELED);
1024 if (dart.notNull(this[_hasPending])) {
1025 this[_pending].cancelSchedule();
1026 }
1027 if (!dart.notNull(this[_inCallback]))
1028 this[_pending] = null;
1029 this[_cancelFuture] = this[_onCancel]();
1030 }
1031 [_incrementPauseCount]() {
1032 this[_state] = dart.notNull(this[_state]) + dart.notNull(_BufferingStrea mSubscription$()._STATE_PAUSE_COUNT) | dart.notNull(_BufferingStreamSubscription $()._STATE_INPUT_PAUSED);
1033 }
1034 [_decrementPauseCount]() {
1035 dart.assert(this[_isPaused]);
1036 this[_state] = dart.notNull(this[_state]) - dart.notNull(_BufferingStrea mSubscription$()._STATE_PAUSE_COUNT);
1037 }
1038 [_add](data) {
1039 dart.as(data, T);
1040 dart.assert(!dart.notNull(this[_isClosed]));
1041 if (dart.notNull(this[_isCanceled]))
1042 return;
1043 if (dart.notNull(this[_canFire])) {
1044 this[_sendData](data);
1045 } else {
1046 this[_addPending](new _DelayedData(data));
1047 }
1048 }
1049 [_addError](error, stackTrace) {
1050 if (dart.notNull(this[_isCanceled]))
1051 return;
1052 if (dart.notNull(this[_canFire])) {
1053 this[_sendError](error, stackTrace);
1054 } else {
1055 this[_addPending](new _DelayedError(error, stackTrace));
1056 }
1057 }
1058 [_close]() {
1059 dart.assert(!dart.notNull(this[_isClosed]));
1060 if (dart.notNull(this[_isCanceled]))
1061 return;
1062 this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStrea mSubscription$()._STATE_CLOSED);
1063 if (dart.notNull(this[_canFire])) {
1064 this[_sendDone]();
1065 } else {
1066 this[_addPending](dart.const(new _DelayedDone()));
1067 }
1068 }
1069 [_onPause]() {
1070 dart.assert(this[_isInputPaused]);
1071 }
1072 [_onResume]() {
1073 dart.assert(!dart.notNull(this[_isInputPaused]));
1074 }
1075 [_onCancel]() {
1076 dart.assert(this[_isCanceled]);
1077 return null;
1078 }
1079 [_addPending](event) {
1080 let pending = dart.as(this[_pending], _StreamImplEvents);
1081 if (this[_pending] == null)
1082 pending = this[_pending] = new _StreamImplEvents();
1083 pending.add(event);
1084 if (!dart.notNull(this[_hasPending])) {
1085 this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStr eamSubscription$()._STATE_HAS_PENDING);
1086 if (!dart.notNull(this[_isPaused])) {
1087 this[_pending].schedule(this);
1088 }
1089 }
1090 }
1091 [_sendData](data) {
1092 dart.as(data, T);
1093 dart.assert(!dart.notNull(this[_isCanceled]));
1094 dart.assert(!dart.notNull(this[_isPaused]));
1095 dart.assert(!dart.notNull(this[_inCallback]));
1096 let wasInputPaused = this[_isInputPaused];
1097 this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStrea mSubscription$()._STATE_IN_CALLBACK);
1098 this[_zone].runUnaryGuarded(this[_onData], data);
1099 this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStre amSubscription$()._STATE_IN_CALLBACK);
1100 this[_checkState](wasInputPaused);
1101 }
1102 [_sendError](error, stackTrace) {
1103 dart.assert(!dart.notNull(this[_isCanceled]));
1104 dart.assert(!dart.notNull(this[_isPaused]));
1105 dart.assert(!dart.notNull(this[_inCallback]));
1106 let wasInputPaused = this[_isInputPaused];
1107 let sendError = (function() {
1108 if (dart.notNull(this[_isCanceled]) && !dart.notNull(this[_waitsForCan cel]))
1109 return;
1110 this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStr eamSubscription$()._STATE_IN_CALLBACK);
1111 if (dart.is(this[_onError], ZoneBinaryCallback)) {
1112 this[_zone].runBinaryGuarded(dart.as(this[_onError], __CastType22), error, stackTrace);
1113 } else {
1114 this[_zone].runUnaryGuarded(dart.as(this[_onError], __CastType25), e rror);
1115 }
1116 this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingSt reamSubscription$()._STATE_IN_CALLBACK);
1117 }).bind(this);
1118 dart.fn(sendError, dart.void, []);
1119 if (dart.notNull(this[_cancelOnError])) {
1120 this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStr eamSubscription$()._STATE_WAIT_FOR_CANCEL);
1121 this[_cancel]();
1122 if (dart.is(this[_cancelFuture], Future)) {
1123 this[_cancelFuture].whenComplete(sendError);
1124 } else {
1125 sendError();
1126 }
1127 } else {
1128 sendError();
1129 this[_checkState](wasInputPaused);
1130 }
1131 }
1132 [_sendDone]() {
1133 dart.assert(!dart.notNull(this[_isCanceled]));
1134 dart.assert(!dart.notNull(this[_isPaused]));
1135 dart.assert(!dart.notNull(this[_inCallback]));
1136 let sendDone = (function() {
1137 if (!dart.notNull(this[_waitsForCancel]))
1138 return;
1139 this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStr eamSubscription$()._STATE_CANCELED) | dart.notNull(_BufferingStreamSubscription$ ()._STATE_CLOSED) | dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLB ACK);
1140 this[_zone].runGuarded(this[_onDone]);
1141 this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingSt reamSubscription$()._STATE_IN_CALLBACK);
1142 }).bind(this);
1143 dart.fn(sendDone, dart.void, []);
1144 this[_cancel]();
1145 this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStrea mSubscription$()._STATE_WAIT_FOR_CANCEL);
1146 if (dart.is(this[_cancelFuture], Future)) {
1147 this[_cancelFuture].whenComplete(sendDone);
1148 } else {
1149 sendDone();
1150 }
1151 }
1152 [_guardCallback](callback) {
1153 dart.assert(!dart.notNull(this[_inCallback]));
1154 let wasInputPaused = this[_isInputPaused];
1155 this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStrea mSubscription$()._STATE_IN_CALLBACK);
1156 dart.dcall(callback);
1157 this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStre amSubscription$()._STATE_IN_CALLBACK);
1158 this[_checkState](wasInputPaused);
1159 }
1160 [_checkState](wasInputPaused) {
1161 dart.assert(!dart.notNull(this[_inCallback]));
1162 if (dart.notNull(this[_hasPending]) && dart.notNull(this[_pending].isEmp ty)) {
1163 this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingSt reamSubscription$()._STATE_HAS_PENDING);
1164 if (dart.notNull(this[_isInputPaused]) && dart.notNull(this[_mayResume Input])) {
1165 this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_Buffering StreamSubscription$()._STATE_INPUT_PAUSED);
1166 }
1167 }
1168 while (true) {
1169 if (dart.notNull(this[_isCanceled])) {
1170 this[_pending] = null;
1171 return;
1172 }
1173 let isInputPaused = this[_isInputPaused];
1174 if (wasInputPaused == isInputPaused)
1175 break;
1176 this[_state] = dart.notNull(this[_state]) ^ dart.notNull(_BufferingStr eamSubscription$()._STATE_IN_CALLBACK);
1177 if (dart.notNull(isInputPaused)) {
1178 this[_onPause]();
1179 } else {
1180 this[_onResume]();
1181 }
1182 this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingSt reamSubscription$()._STATE_IN_CALLBACK);
1183 wasInputPaused = isInputPaused;
1184 }
1185 if (dart.notNull(this[_hasPending]) && !dart.notNull(this[_isPaused])) {
1186 this[_pending].schedule(this);
1187 }
1188 }
1189 }
1190 _BufferingStreamSubscription[dart.implements] = () => [StreamSubscription$(T ), _EventSink$(T), _EventDispatch$(T)];
1191 dart.setSignature(_BufferingStreamSubscription, {
1192 constructors: () => ({_BufferingStreamSubscription: [_BufferingStreamSubsc ription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionTyp e(dart.void, []), core.bool]]}),
1193 methods: () => ({
1194 [_setPendingEvents]: [dart.void, [_PendingEvents]],
1195 [_extractPending]: [_PendingEvents, []],
1196 onData: [dart.void, [dart.functionType(dart.void, [T])]],
1197 onError: [dart.void, [core.Function]],
1198 onDone: [dart.void, [dart.functionType(dart.void, [])]],
1199 pause: [dart.void, [], [Future]],
1200 resume: [dart.void, []],
1201 cancel: [Future, []],
1202 asFuture: [Future, [], [dart.dynamic]],
1203 [_cancel]: [dart.void, []],
1204 [_incrementPauseCount]: [dart.void, []],
1205 [_decrementPauseCount]: [dart.void, []],
1206 [_add]: [dart.void, [T]],
1207 [_addError]: [dart.void, [core.Object, core.StackTrace]],
1208 [_close]: [dart.void, []],
1209 [_onPause]: [dart.void, []],
1210 [_onResume]: [dart.void, []],
1211 [_onCancel]: [Future, []],
1212 [_addPending]: [dart.void, [_DelayedEvent]],
1213 [_sendData]: [dart.void, [T]],
1214 [_sendError]: [dart.void, [core.Object, core.StackTrace]],
1215 [_sendDone]: [dart.void, []],
1216 [_guardCallback]: [dart.void, [dart.dynamic]],
1217 [_checkState]: [dart.void, [core.bool]]
1218 })
1219 });
1220 return _BufferingStreamSubscription;
1221 });
1222 let _BufferingStreamSubscription = _BufferingStreamSubscription$();
1223 let _recordCancel = Symbol('_recordCancel');
1224 let _recordPause = Symbol('_recordPause');
1225 let _recordResume = Symbol('_recordResume');
1226 let _ControllerSubscription$ = dart.generic(function(T) {
1227 class _ControllerSubscription extends _BufferingStreamSubscription$(T) {
1228 _ControllerSubscription(controller, onData, onError, onDone, cancelOnError ) {
1229 this[_controller] = controller;
1230 super._BufferingStreamSubscription(onData, onError, onDone, cancelOnErro r);
1231 }
1232 [_onCancel]() {
1233 return this[_controller][_recordCancel](this);
1234 }
1235 [_onPause]() {
1236 this[_controller][_recordPause](this);
1237 }
1238 [_onResume]() {
1239 this[_controller][_recordResume](this);
1240 }
1241 }
1242 dart.setSignature(_ControllerSubscription, {
1243 constructors: () => ({_ControllerSubscription: [_ControllerSubscription$(T ), [_StreamControllerLifecycle$(T), dart.functionType(dart.void, [T]), core.Func tion, dart.functionType(dart.void, []), core.bool]]})
1244 });
1245 return _ControllerSubscription;
1246 });
1247 let _ControllerSubscription = _ControllerSubscription$();
1248 let _eventState = Symbol('_eventState');
1249 let _expectsEvent = Symbol('_expectsEvent');
1250 let _toggleEventId = Symbol('_toggleEventId');
1251 let _isFiring = Symbol('_isFiring');
1252 let _setRemoveAfterFiring = Symbol('_setRemoveAfterFiring');
1253 let _removeAfterFiring = Symbol('_removeAfterFiring');
1254 let _BroadcastSubscription$ = dart.generic(function(T) {
1255 class _BroadcastSubscription extends _ControllerSubscription$(T) {
1256 _BroadcastSubscription(controller, onData, onError, onDone, cancelOnError) {
1257 this[_eventState] = null;
1258 this[_next] = null;
1259 this[_previous] = null;
1260 super._ControllerSubscription(dart.as(controller, _StreamControllerLifec ycle$(T)), onData, onError, onDone, cancelOnError);
1261 this[_next] = this[_previous] = this;
1262 }
1263 get [_controller]() {
1264 return dart.as(super[_controller], _BroadcastStreamController$(T));
1265 }
1266 [_expectsEvent](eventId) {
1267 return (dart.notNull(this[_eventState]) & dart.notNull(_BroadcastSubscri ption$()._STATE_EVENT_ID)) == eventId;
1268 }
1269 [_toggleEventId]() {
1270 this[_eventState] = dart.notNull(this[_eventState]) ^ dart.notNull(_Broa dcastSubscription$()._STATE_EVENT_ID);
1271 }
1272 get [_isFiring]() {
1273 return (dart.notNull(this[_eventState]) & dart.notNull(_BroadcastSubscri ption$()._STATE_FIRING)) != 0;
1274 }
1275 [_setRemoveAfterFiring]() {
1276 dart.assert(this[_isFiring]);
1277 this[_eventState] = dart.notNull(this[_eventState]) | dart.notNull(_Broa dcastSubscription$()._STATE_REMOVE_AFTER_FIRING);
1278 }
1279 get [_removeAfterFiring]() {
1280 return (dart.notNull(this[_eventState]) & dart.notNull(_BroadcastSubscri ption$()._STATE_REMOVE_AFTER_FIRING)) != 0;
1281 }
1282 [_onPause]() {}
1283 [_onResume]() {}
1284 }
1285 _BroadcastSubscription[dart.implements] = () => [_BroadcastSubscriptionLink] ;
1286 dart.setSignature(_BroadcastSubscription, {
1287 constructors: () => ({_BroadcastSubscription: [_BroadcastSubscription$(T), [_StreamControllerLifecycle, dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]]}),
1288 methods: () => ({
1289 [_expectsEvent]: [core.bool, [core.int]],
1290 [_toggleEventId]: [dart.void, []],
1291 [_setRemoveAfterFiring]: [dart.void, []]
1292 })
1293 });
1294 return _BroadcastSubscription;
1295 });
1296 let _BroadcastSubscription = _BroadcastSubscription$();
1297 _BroadcastSubscription._STATE_EVENT_ID = 1;
1298 _BroadcastSubscription._STATE_FIRING = 2;
1299 _BroadcastSubscription._STATE_REMOVE_AFTER_FIRING = 4;
1300 let _addStreamState = Symbol('_addStreamState');
1301 let _doneFuture = Symbol('_doneFuture');
1302 let _isEmpty = Symbol('_isEmpty');
1303 let _hasOneListener = Symbol('_hasOneListener');
1304 let _isAddingStream = Symbol('_isAddingStream');
1305 let _mayAddEvent = Symbol('_mayAddEvent');
1306 let _ensureDoneFuture = Symbol('_ensureDoneFuture');
1307 let _addListener = Symbol('_addListener');
1308 let _removeListener = Symbol('_removeListener');
1309 let _callOnCancel = Symbol('_callOnCancel');
1310 let _addEventError = Symbol('_addEventError');
1311 let _forEachListener = Symbol('_forEachListener');
1312 let _mayComplete = Symbol('_mayComplete');
1313 let _asyncComplete = Symbol('_asyncComplete');
1314 let _BroadcastStreamController$ = dart.generic(function(T) {
1315 class _BroadcastStreamController extends core.Object {
1316 _BroadcastStreamController(onListen, onCancel) {
1317 this[_onListen] = onListen;
1318 this[_onCancel] = onCancel;
1319 this[_state] = _BroadcastStreamController$()._STATE_INITIAL;
1320 this[_next] = null;
1321 this[_previous] = null;
1322 this[_addStreamState] = null;
1323 this[_doneFuture] = null;
1324 this[_next] = this[_previous] = this;
1325 }
1326 get stream() {
1327 return new (_BroadcastStream$(T))(this);
1328 }
1329 get sink() {
1330 return new (_StreamSinkWrapper$(T))(this);
1331 }
1332 get isClosed() {
1333 return (dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamContro ller$()._STATE_CLOSED)) != 0;
1334 }
1335 get isPaused() {
1336 return false;
1337 }
1338 get hasListener() {
1339 return !dart.notNull(this[_isEmpty]);
1340 }
1341 get [_hasOneListener]() {
1342 dart.assert(!dart.notNull(this[_isEmpty]));
1343 return core.identical(this[_next][_next], this);
1344 }
1345 get [_isFiring]() {
1346 return (dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamContro ller$()._STATE_FIRING)) != 0;
1347 }
1348 get [_isAddingStream]() {
1349 return (dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamContro ller$()._STATE_ADDSTREAM)) != 0;
1350 }
1351 get [_mayAddEvent]() {
1352 return dart.notNull(this[_state]) < dart.notNull(_BroadcastStreamControl ler$()._STATE_CLOSED);
1353 }
1354 [_ensureDoneFuture]() {
1355 if (this[_doneFuture] != null)
1356 return this[_doneFuture];
1357 return this[_doneFuture] = new _Future();
1358 }
1359 get [_isEmpty]() {
1360 return core.identical(this[_next], this);
1361 }
1362 [_addListener](subscription) {
1363 dart.as(subscription, _BroadcastSubscription$(T));
1364 dart.assert(core.identical(subscription[_next], subscription));
1365 subscription[_previous] = this[_previous];
1366 subscription[_next] = this;
1367 this[_previous][_next] = subscription;
1368 this[_previous] = subscription;
1369 subscription[_eventState] = dart.notNull(this[_state]) & dart.notNull(_B roadcastStreamController$()._STATE_EVENT_ID);
1370 }
1371 [_removeListener](subscription) {
1372 dart.as(subscription, _BroadcastSubscription$(T));
1373 dart.assert(core.identical(subscription[_controller], this));
1374 dart.assert(!dart.notNull(core.identical(subscription[_next], subscripti on)));
1375 let previous = subscription[_previous];
1376 let next = subscription[_next];
1377 previous[_next] = next;
1378 next[_previous] = previous;
1379 subscription[_next] = subscription[_previous] = subscription;
1380 }
1381 [_subscribe](onData, onError, onDone, cancelOnError) {
1382 dart.as(onData, dart.functionType(dart.void, [T]));
1383 dart.as(onDone, dart.functionType(dart.void, []));
1384 if (dart.notNull(this.isClosed)) {
1385 if (onDone == null)
1386 onDone = _nullDoneHandler;
1387 return new (_DoneStreamSubscription$(T))(onDone);
1388 }
1389 let subscription = new (_BroadcastSubscription$(T))(this, onData, onErro r, onDone, cancelOnError);
1390 this[_addListener](dart.as(subscription, _BroadcastSubscription$(T)));
1391 if (dart.notNull(core.identical(this[_next], this[_previous]))) {
1392 _runGuarded(this[_onListen]);
1393 }
1394 return dart.as(subscription, StreamSubscription$(T));
1395 }
1396 [_recordCancel](subscription) {
1397 dart.as(subscription, StreamSubscription$(T));
1398 if (dart.notNull(core.identical(subscription[_next], subscription)))
1399 return null;
1400 dart.assert(!dart.notNull(core.identical(subscription[_next], subscripti on)));
1401 if (dart.notNull(dart.as(subscription[_isFiring], core.bool))) {
1402 dart.dcall(subscription[_setRemoveAfterFiring]);
1403 } else {
1404 dart.assert(!dart.notNull(core.identical(subscription[_next], subscrip tion)));
1405 this[_removeListener](dart.as(subscription, _BroadcastSubscription$(T) ));
1406 if (!dart.notNull(this[_isFiring]) && dart.notNull(this[_isEmpty])) {
1407 this[_callOnCancel]();
1408 }
1409 }
1410 return null;
1411 }
1412 [_recordPause](subscription) {
1413 dart.as(subscription, StreamSubscription$(T));
1414 }
1415 [_recordResume](subscription) {
1416 dart.as(subscription, StreamSubscription$(T));
1417 }
1418 [_addEventError]() {
1419 if (dart.notNull(this.isClosed)) {
1420 return new core.StateError("Cannot add new events after calling close" );
1421 }
1422 dart.assert(this[_isAddingStream]);
1423 return new core.StateError("Cannot add new events while doing an addStre am");
1424 }
1425 add(data) {
1426 dart.as(data, T);
1427 if (!dart.notNull(this[_mayAddEvent]))
1428 dart.throw(this[_addEventError]());
1429 this[_sendData](data);
1430 }
1431 addError(error, stackTrace) {
1432 if (stackTrace === void 0)
1433 stackTrace = null;
1434 error = _nonNullError(error);
1435 if (!dart.notNull(this[_mayAddEvent]))
1436 dart.throw(this[_addEventError]());
1437 let replacement = Zone.current.errorCallback(error, stackTrace);
1438 if (replacement != null) {
1439 error = _nonNullError(replacement.error);
1440 stackTrace = replacement.stackTrace;
1441 }
1442 this[_sendError](error, stackTrace);
1443 }
1444 close() {
1445 if (dart.notNull(this.isClosed)) {
1446 dart.assert(this[_doneFuture] != null);
1447 return this[_doneFuture];
1448 }
1449 if (!dart.notNull(this[_mayAddEvent]))
1450 dart.throw(this[_addEventError]());
1451 this[_state] = dart.notNull(this[_state]) | dart.notNull(_BroadcastStrea mController$()._STATE_CLOSED);
1452 let doneFuture = this[_ensureDoneFuture]();
1453 this[_sendDone]();
1454 return doneFuture;
1455 }
1456 get done() {
1457 return this[_ensureDoneFuture]();
1458 }
1459 addStream(stream, opts) {
1460 dart.as(stream, Stream$(T));
1461 let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : true;
1462 if (!dart.notNull(this[_mayAddEvent]))
1463 dart.throw(this[_addEventError]());
1464 this[_state] = dart.notNull(this[_state]) | dart.notNull(_BroadcastStrea mController$()._STATE_ADDSTREAM);
1465 this[_addStreamState] = new (_AddStreamState$(T))(this, stream, cancelOn Error);
1466 return this[_addStreamState].addStreamFuture;
1467 }
1468 [_add](data) {
1469 dart.as(data, T);
1470 this[_sendData](data);
1471 }
1472 [_addError](error, stackTrace) {
1473 this[_sendError](error, stackTrace);
1474 }
1475 [_close]() {
1476 dart.assert(this[_isAddingStream]);
1477 let addState = this[_addStreamState];
1478 this[_addStreamState] = null;
1479 this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BroadcastStre amController$()._STATE_ADDSTREAM);
1480 addState.complete();
1481 }
1482 [_forEachListener](action) {
1483 dart.as(action, dart.functionType(dart.void, [_BufferingStreamSubscripti on$(T)]));
1484 if (dart.notNull(this[_isFiring])) {
1485 dart.throw(new core.StateError("Cannot fire new event. Controller is a lready firing an event"));
1486 }
1487 if (dart.notNull(this[_isEmpty]))
1488 return;
1489 let id = dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamContr oller$()._STATE_EVENT_ID);
1490 this[_state] = dart.notNull(this[_state]) ^ (dart.notNull(_BroadcastStre amController$()._STATE_EVENT_ID) | dart.notNull(_BroadcastStreamController$()._S TATE_FIRING));
1491 let link = this[_next];
1492 while (!dart.notNull(core.identical(link, this))) {
1493 let subscription = dart.as(link, _BroadcastSubscription$(T));
1494 if (dart.notNull(subscription[_expectsEvent](id))) {
1495 subscription[_eventState] = dart.notNull(subscription[_eventState]) | dart.notNull(_BroadcastSubscription._STATE_FIRING);
1496 action(subscription);
1497 subscription[_toggleEventId]();
1498 link = subscription[_next];
1499 if (dart.notNull(subscription[_removeAfterFiring])) {
1500 this[_removeListener](subscription);
1501 }
1502 subscription[_eventState] = dart.notNull(subscription[_eventState]) & ~dart.notNull(_BroadcastSubscription._STATE_FIRING);
1503 } else {
1504 link = subscription[_next];
1505 }
1506 }
1507 this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BroadcastStre amController$()._STATE_FIRING);
1508 if (dart.notNull(this[_isEmpty])) {
1509 this[_callOnCancel]();
1510 }
1511 }
1512 [_callOnCancel]() {
1513 dart.assert(this[_isEmpty]);
1514 if (dart.notNull(this.isClosed) && dart.notNull(this[_doneFuture][_mayCo mplete])) {
1515 this[_doneFuture][_asyncComplete](null);
1516 }
1517 _runGuarded(this[_onCancel]);
1518 }
1519 }
1520 _BroadcastStreamController[dart.implements] = () => [StreamController$(T), _ StreamControllerLifecycle$(T), _BroadcastSubscriptionLink, _EventSink$(T), _Even tDispatch$(T)];
1521 dart.setSignature(_BroadcastStreamController, {
1522 constructors: () => ({_BroadcastStreamController: [_BroadcastStreamControl ler$(T), [_NotificationHandler, _NotificationHandler]]}),
1523 methods: () => ({
1524 [_ensureDoneFuture]: [_Future, []],
1525 [_addListener]: [dart.void, [_BroadcastSubscription$(T)]],
1526 [_removeListener]: [dart.void, [_BroadcastSubscription$(T)]],
1527 [_subscribe]: [StreamSubscription$(T), [dart.functionType(dart.void, [T] ), core.Function, dart.functionType(dart.void, []), core.bool]],
1528 [_recordCancel]: [Future, [StreamSubscription$(T)]],
1529 [_recordPause]: [dart.void, [StreamSubscription$(T)]],
1530 [_recordResume]: [dart.void, [StreamSubscription$(T)]],
1531 [_addEventError]: [core.Error, []],
1532 add: [dart.void, [T]],
1533 addError: [dart.void, [core.Object], [core.StackTrace]],
1534 close: [Future, []],
1535 addStream: [Future, [Stream$(T)], {cancelOnError: core.bool}],
1536 [_add]: [dart.void, [T]],
1537 [_addError]: [dart.void, [core.Object, core.StackTrace]],
1538 [_close]: [dart.void, []],
1539 [_forEachListener]: [dart.void, [dart.functionType(dart.void, [_Bufferin gStreamSubscription$(T)])]],
1540 [_callOnCancel]: [dart.void, []]
1541 })
1542 });
1543 return _BroadcastStreamController;
1544 });
1545 let _BroadcastStreamController = _BroadcastStreamController$();
1546 _BroadcastStreamController._STATE_INITIAL = 0;
1547 _BroadcastStreamController._STATE_EVENT_ID = 1;
1548 _BroadcastStreamController._STATE_FIRING = 2;
1549 _BroadcastStreamController._STATE_CLOSED = 4;
1550 _BroadcastStreamController._STATE_ADDSTREAM = 8;
1551 let _SyncBroadcastStreamController$ = dart.generic(function(T) {
1552 class _SyncBroadcastStreamController extends _BroadcastStreamController$(T) {
1553 _SyncBroadcastStreamController(onListen, onCancel) {
1554 super._BroadcastStreamController(onListen, onCancel);
1555 }
1556 [_sendData](data) {
1557 dart.as(data, T);
1558 if (dart.notNull(this[_isEmpty]))
1559 return;
1560 if (dart.notNull(this[_hasOneListener])) {
1561 this[_state] = dart.notNull(this[_state]) | dart.notNull(_BroadcastStr eamController._STATE_FIRING);
1562 let subscription = dart.as(this[_next], _BroadcastSubscription);
1563 subscription[_add](data);
1564 this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BroadcastSt reamController._STATE_FIRING);
1565 if (dart.notNull(this[_isEmpty])) {
1566 this[_callOnCancel]();
1567 }
1568 return;
1569 }
1570 this[_forEachListener](dart.fn(subscription => {
1571 dart.as(subscription, _BufferingStreamSubscription$(T));
1572 subscription[_add](data);
1573 }, dart.dynamic, [_BufferingStreamSubscription$(T)]));
1574 }
1575 [_sendError](error, stackTrace) {
1576 if (dart.notNull(this[_isEmpty]))
1577 return;
1578 this[_forEachListener](dart.fn(subscription => {
1579 dart.as(subscription, _BufferingStreamSubscription$(T));
1580 subscription[_addError](error, stackTrace);
1581 }, dart.dynamic, [_BufferingStreamSubscription$(T)]));
1582 }
1583 [_sendDone]() {
1584 if (!dart.notNull(this[_isEmpty])) {
1585 this[_forEachListener](dart.as(dart.fn(subscription => {
1586 dart.as(subscription, _BroadcastSubscription$(T));
1587 subscription[_close]();
1588 }, dart.dynamic, [_BroadcastSubscription$(T)]), __CastType2));
1589 } else {
1590 dart.assert(this[_doneFuture] != null);
1591 dart.assert(this[_doneFuture][_mayComplete]);
1592 this[_doneFuture][_asyncComplete](null);
1593 }
1594 }
1595 }
1596 dart.setSignature(_SyncBroadcastStreamController, {
1597 constructors: () => ({_SyncBroadcastStreamController: [_SyncBroadcastStrea mController$(T), [dart.functionType(dart.void, []), dart.functionType(dart.void, [])]]}),
1598 methods: () => ({
1599 [_sendData]: [dart.void, [T]],
1600 [_sendError]: [dart.void, [core.Object, core.StackTrace]],
1601 [_sendDone]: [dart.void, []]
1602 })
1603 });
1604 return _SyncBroadcastStreamController;
1605 });
1606 let _SyncBroadcastStreamController = _SyncBroadcastStreamController$();
1607 let _AsyncBroadcastStreamController$ = dart.generic(function(T) {
1608 class _AsyncBroadcastStreamController extends _BroadcastStreamController$(T) {
1609 _AsyncBroadcastStreamController(onListen, onCancel) {
1610 super._BroadcastStreamController(onListen, onCancel);
1611 }
1612 [_sendData](data) {
1613 dart.as(data, T);
1614 for (let link = this[_next]; !dart.notNull(core.identical(link, this)); link = link[_next]) {
1615 let subscription = dart.as(link, _BroadcastSubscription$(T));
1616 subscription[_addPending](new _DelayedData(data));
1617 }
1618 }
1619 [_sendError](error, stackTrace) {
1620 for (let link = this[_next]; !dart.notNull(core.identical(link, this)); link = link[_next]) {
1621 let subscription = dart.as(link, _BroadcastSubscription$(T));
1622 subscription[_addPending](new _DelayedError(error, stackTrace));
1623 }
1624 }
1625 [_sendDone]() {
1626 if (!dart.notNull(this[_isEmpty])) {
1627 for (let link = this[_next]; !dart.notNull(core.identical(link, this)) ; link = link[_next]) {
1628 let subscription = dart.as(link, _BroadcastSubscription$(T));
1629 subscription[_addPending](dart.const(new _DelayedDone()));
1630 }
1631 } else {
1632 dart.assert(this[_doneFuture] != null);
1633 dart.assert(this[_doneFuture][_mayComplete]);
1634 this[_doneFuture][_asyncComplete](null);
1635 }
1636 }
1637 }
1638 dart.setSignature(_AsyncBroadcastStreamController, {
1639 constructors: () => ({_AsyncBroadcastStreamController: [_AsyncBroadcastStr eamController$(T), [dart.functionType(dart.void, []), dart.functionType(dart.voi d, [])]]}),
1640 methods: () => ({
1641 [_sendData]: [dart.void, [T]],
1642 [_sendError]: [dart.void, [core.Object, core.StackTrace]],
1643 [_sendDone]: [dart.void, []]
1644 })
1645 });
1646 return _AsyncBroadcastStreamController;
1647 });
1648 let _AsyncBroadcastStreamController = _AsyncBroadcastStreamController$();
1649 let _addPendingEvent = Symbol('_addPendingEvent');
1650 let _AsBroadcastStreamController$ = dart.generic(function(T) {
1651 class _AsBroadcastStreamController extends _SyncBroadcastStreamController$(T ) {
1652 _AsBroadcastStreamController(onListen, onCancel) {
1653 this[_pending] = null;
1654 super._SyncBroadcastStreamController(onListen, onCancel);
1655 }
1656 get [_hasPending]() {
1657 return this[_pending] != null && !dart.notNull(this[_pending].isEmpty);
1658 }
1659 [_addPendingEvent](event) {
1660 if (this[_pending] == null) {
1661 this[_pending] = new _StreamImplEvents();
1662 }
1663 this[_pending].add(event);
1664 }
1665 add(data) {
1666 dart.as(data, T);
1667 if (!dart.notNull(this.isClosed) && dart.notNull(this[_isFiring])) {
1668 this[_addPendingEvent](new (_DelayedData$(T))(data));
1669 return;
1670 }
1671 super.add(data);
1672 while (dart.notNull(this[_hasPending])) {
1673 this[_pending].handleNext(this);
1674 }
1675 }
1676 addError(error, stackTrace) {
1677 if (stackTrace === void 0)
1678 stackTrace = null;
1679 if (!dart.notNull(this.isClosed) && dart.notNull(this[_isFiring])) {
1680 this[_addPendingEvent](new _DelayedError(error, stackTrace));
1681 return;
1682 }
1683 if (!dart.notNull(this[_mayAddEvent]))
1684 dart.throw(this[_addEventError]());
1685 this[_sendError](error, stackTrace);
1686 while (dart.notNull(this[_hasPending])) {
1687 this[_pending].handleNext(this);
1688 }
1689 }
1690 close() {
1691 if (!dart.notNull(this.isClosed) && dart.notNull(this[_isFiring])) {
1692 this[_addPendingEvent](dart.const(new _DelayedDone()));
1693 this[_state] = dart.notNull(this[_state]) | dart.notNull(_BroadcastStr eamController._STATE_CLOSED);
1694 return super.done;
1695 }
1696 let result = super.close();
1697 dart.assert(!dart.notNull(this[_hasPending]));
1698 return result;
1699 }
1700 [_callOnCancel]() {
1701 if (dart.notNull(this[_hasPending])) {
1702 this[_pending].clear();
1703 this[_pending] = null;
1704 }
1705 super[_callOnCancel]();
1706 }
1707 }
1708 _AsBroadcastStreamController[dart.implements] = () => [_EventDispatch$(T)];
1709 dart.setSignature(_AsBroadcastStreamController, {
1710 constructors: () => ({_AsBroadcastStreamController: [_AsBroadcastStreamCon troller$(T), [dart.functionType(dart.void, []), dart.functionType(dart.void, []) ]]}),
1711 methods: () => ({
1712 [_addPendingEvent]: [dart.void, [_DelayedEvent]],
1713 add: [dart.void, [T]]
1714 })
1715 });
1716 return _AsBroadcastStreamController;
1717 });
1718 let _AsBroadcastStreamController = _AsBroadcastStreamController$();
1719 let _pauseCount = Symbol('_pauseCount');
1720 let _resume = Symbol('_resume');
1721 let _DoneSubscription$ = dart.generic(function(T) {
1722 class _DoneSubscription extends core.Object {
1723 _DoneSubscription() {
1724 this[_pauseCount] = 0;
1725 }
1726 onData(handleData) {
1727 dart.as(handleData, dart.functionType(dart.void, [T]));
1728 }
1729 onError(handleError) {}
1730 onDone(handleDone) {
1731 dart.as(handleDone, dart.functionType(dart.void, []));
1732 }
1733 pause(resumeSignal) {
1734 if (resumeSignal === void 0)
1735 resumeSignal = null;
1736 if (resumeSignal != null)
1737 resumeSignal.then(dart.bind(this, _resume));
1738 this[_pauseCount] = dart.notNull(this[_pauseCount]) + 1;
1739 }
1740 resume() {
1741 this[_resume](null);
1742 }
1743 [_resume](_) {
1744 if (dart.notNull(this[_pauseCount]) > 0) {
1745 this[_pauseCount] = dart.notNull(this[_pauseCount]) - 1;
1746 }
1747 }
1748 cancel() {
1749 return new _Future.immediate(null);
1750 }
1751 get isPaused() {
1752 return dart.notNull(this[_pauseCount]) > 0;
1753 }
1754 asFuture(value) {
1755 if (value === void 0)
1756 value = null;
1757 return new _Future();
1758 }
1759 }
1760 _DoneSubscription[dart.implements] = () => [StreamSubscription$(T)];
1761 dart.setSignature(_DoneSubscription, {
1762 methods: () => ({
1763 onData: [dart.void, [dart.functionType(dart.void, [T])]],
1764 onError: [dart.void, [core.Function]],
1765 onDone: [dart.void, [dart.functionType(dart.void, [])]],
1766 pause: [dart.void, [], [Future]],
1767 resume: [dart.void, []],
1768 [_resume]: [dart.void, [dart.dynamic]],
1769 cancel: [Future, []],
1770 asFuture: [Future, [], [core.Object]]
1771 })
1772 });
1773 return _DoneSubscription;
1774 });
1775 let _DoneSubscription = _DoneSubscription$();
1776 let __CastType2$ = dart.generic(function(T) {
1777 let __CastType2 = dart.typedef('__CastType2', () => dart.functionType(dart.v oid, [_BufferingStreamSubscription$(T)]));
1778 return __CastType2;
1779 });
1780 let __CastType2 = __CastType2$();
1781 class DeferredLibrary extends core.Object {
1782 DeferredLibrary(libraryName, opts) {
1783 let uri = opts && 'uri' in opts ? opts.uri : null;
1784 this.libraryName = libraryName;
1785 this.uri = uri;
1786 }
1787 load() {
1788 dart.throw('DeferredLibrary not supported. ' + 'please use the `import "li b.dart" deferred as lib` syntax.');
1789 }
1790 }
1791 dart.setSignature(DeferredLibrary, {
1792 constructors: () => ({DeferredLibrary: [DeferredLibrary, [core.String], {uri : core.String}]}),
1793 methods: () => ({load: [Future$(core.Null), []]})
1794 });
1795 DeferredLibrary[dart.metadata] = () => [dart.const(new core.Deprecated("Dart s dk v. 1.8"))];
1796 let _s = Symbol('_s');
1797 class DeferredLoadException extends core.Object {
1798 DeferredLoadException(s) {
1799 this[_s] = s;
1800 }
1801 toString() {
1802 return `DeferredLoadException: '${this[_s]}'`;
1803 }
1804 }
1805 DeferredLoadException[dart.implements] = () => [core.Exception];
1806 dart.setSignature(DeferredLoadException, {
1807 constructors: () => ({DeferredLoadException: [DeferredLoadException, [core.S tring]]})
1808 });
1809 let _completeWithValue = Symbol('_completeWithValue');
1810 let Future$ = dart.generic(function(T) {
1811 class Future extends core.Object {
1812 static new(computation) {
1813 let result = new (_Future$(T))();
1814 Timer.run(dart.fn(() => {
1815 try {
1816 result[_complete](computation());
1817 } catch (e) {
1818 let s = dart.stackTrace(e);
1819 _completeWithErrorCallback(result, e, s);
1820 }
1821
1822 }));
1823 return dart.as(result, Future$(T));
1824 }
1825 static microtask(computation) {
1826 let result = new (_Future$(T))();
1827 scheduleMicrotask(dart.fn(() => {
1828 try {
1829 result[_complete](computation());
1830 } catch (e) {
1831 let s = dart.stackTrace(e);
1832 _completeWithErrorCallback(result, e, s);
1833 }
1834
1835 }));
1836 return dart.as(result, Future$(T));
1837 }
1838 static sync(computation) {
1839 try {
1840 let result = computation();
1841 return Future$(T).value(result);
1842 } catch (error) {
1843 let stackTrace = dart.stackTrace(error);
1844 return Future$(T).error(error, stackTrace);
1845 }
1846
1847 }
1848 static value(value) {
1849 if (value === void 0)
1850 value = null;
1851 return new (_Future$(T)).immediate(value);
1852 }
1853 static error(error, stackTrace) {
1854 if (stackTrace === void 0)
1855 stackTrace = null;
1856 error = _nonNullError(error);
1857 if (!dart.notNull(core.identical(Zone.current, _ROOT_ZONE))) {
1858 let replacement = Zone.current.errorCallback(error, stackTrace);
1859 if (replacement != null) {
1860 error = _nonNullError(replacement.error);
1861 stackTrace = replacement.stackTrace;
1862 }
1863 }
1864 return new (_Future$(T)).immediateError(error, stackTrace);
1865 }
1866 static delayed(duration, computation) {
1867 if (computation === void 0)
1868 computation = null;
1869 let result = new (_Future$(T))();
1870 Timer.new(duration, dart.fn(() => {
1871 try {
1872 result[_complete](computation == null ? null : computation());
1873 } catch (e) {
1874 let s = dart.stackTrace(e);
1875 _completeWithErrorCallback(result, e, s);
1876 }
1877
1878 }));
1879 return dart.as(result, Future$(T));
1880 }
1881 static wait(futures, opts) {
1882 let eagerError = opts && 'eagerError' in opts ? opts.eagerError : false;
1883 let cleanUp = opts && 'cleanUp' in opts ? opts.cleanUp : null;
1884 dart.as(cleanUp, dart.functionType(dart.void, [dart.dynamic]));
1885 let result = new (_Future$(core.List))();
1886 let values = null;
1887 let remaining = 0;
1888 let error = null;
1889 let stackTrace = null;
1890 function handleError(theError, theStackTrace) {
1891 remaining = dart.notNull(remaining) - 1;
1892 if (values != null) {
1893 if (cleanUp != null) {
1894 for (let value of values) {
1895 if (value != null) {
1896 Future$().sync(dart.fn(() => {
1897 dart.dcall(cleanUp, value);
1898 }));
1899 }
1900 }
1901 }
1902 values = null;
1903 if (remaining == 0 || dart.notNull(eagerError)) {
1904 result[_completeError](theError, dart.as(theStackTrace, core.Stack Trace));
1905 } else {
1906 error = theError;
1907 stackTrace = dart.as(theStackTrace, core.StackTrace);
1908 }
1909 } else if (remaining == 0 && !dart.notNull(eagerError)) {
1910 result[_completeError](error, stackTrace);
1911 }
1912 }
1913 dart.fn(handleError, dart.void, [dart.dynamic, dart.dynamic]);
1914 for (let future of futures) {
1915 let pos = remaining;
1916 remaining = dart.notNull(pos) + 1;
1917 future.then(dart.fn(value => {
1918 remaining = dart.notNull(remaining) - 1;
1919 if (values != null) {
1920 values[dartx.set](pos, value);
1921 if (remaining == 0) {
1922 result[_completeWithValue](values);
1923 }
1924 } else {
1925 if (cleanUp != null && value != null) {
1926 Future$().sync(dart.fn(() => {
1927 dart.dcall(cleanUp, value);
1928 }));
1929 }
1930 if (remaining == 0 && !dart.notNull(eagerError)) {
1931 result[_completeError](error, stackTrace);
1932 }
1933 }
1934 }, dart.dynamic, [core.Object]), {onError: handleError});
1935 }
1936 if (remaining == 0) {
1937 return Future$(core.List).value(dart.const([]));
1938 }
1939 values = core.List.new(remaining);
1940 return result;
1941 }
1942 static forEach(input, f) {
1943 dart.as(f, dart.functionType(dart.dynamic, [dart.dynamic]));
1944 let iterator = input[dartx.iterator];
1945 return Future$().doWhile(dart.fn(() => {
1946 if (!dart.notNull(iterator.moveNext()))
1947 return false;
1948 return Future$().sync(dart.fn(() => dart.dcall(f, iterator.current))). then(dart.fn(_ => true, core.bool, [dart.dynamic]));
1949 }));
1950 }
1951 static doWhile(f) {
1952 dart.as(f, dart.functionType(dart.dynamic, []));
1953 let doneSignal = new _Future();
1954 let nextIteration = null;
1955 nextIteration = Zone.current.bindUnaryCallback(dart.fn(keepGoing => {
1956 if (dart.notNull(keepGoing)) {
1957 Future$().sync(f).then(dart.as(nextIteration, __CastType4), {onError : dart.bind(doneSignal, _completeError)});
1958 } else {
1959 doneSignal[_complete](null);
1960 }
1961 }, dart.dynamic, [core.bool]), {runGuarded: true});
1962 dart.dcall(nextIteration, true);
1963 return doneSignal;
1964 }
1965 }
1966 dart.setSignature(Future, {
1967 constructors: () => ({
1968 new: [Future$(T), [dart.functionType(dart.dynamic, [])]],
1969 microtask: [Future$(T), [dart.functionType(dart.dynamic, [])]],
1970 sync: [Future$(T), [dart.functionType(dart.dynamic, [])]],
1971 value: [Future$(T), [], [dart.dynamic]],
1972 error: [Future$(T), [core.Object], [core.StackTrace]],
1973 delayed: [Future$(T), [core.Duration], [dart.functionType(T, [])]]
1974 }),
1975 statics: () => ({
1976 wait: [Future$(core.List), [core.Iterable$(Future$())], {eagerError: cor e.bool, cleanUp: dart.functionType(dart.void, [dart.dynamic])}],
1977 forEach: [Future$(), [core.Iterable, dart.functionType(dart.dynamic, [da rt.dynamic])]],
1978 doWhile: [Future$(), [dart.functionType(dart.dynamic, [])]]
1979 }),
1980 names: ['wait', 'forEach', 'doWhile']
1981 });
1982 return Future;
1983 });
1984 let Future = Future$();
1985 dart.defineLazyProperties(Future, {
1986 get _nullFuture() {
1987 return new _Future.immediate(null);
1988 }
1989 });
1990 class TimeoutException extends core.Object {
1991 TimeoutException(message, duration) {
1992 if (duration === void 0)
1993 duration = null;
1994 this.message = message;
1995 this.duration = duration;
1996 }
1997 toString() {
1998 let result = "TimeoutException";
1999 if (this.duration != null)
2000 result = `TimeoutException after ${this.duration}`;
2001 if (this.message != null)
2002 result = `${result}: ${this.message}`;
2003 return result;
2004 }
2005 }
2006 TimeoutException[dart.implements] = () => [core.Exception];
2007 dart.setSignature(TimeoutException, {
2008 constructors: () => ({TimeoutException: [TimeoutException, [core.String], [c ore.Duration]]})
2009 });
2010 let Completer$ = dart.generic(function(T) {
2011 class Completer extends core.Object {
2012 static new() {
2013 return new (_AsyncCompleter$(T))();
2014 }
2015 static sync() {
2016 return new (_SyncCompleter$(T))();
2017 }
2018 }
2019 dart.setSignature(Completer, {
2020 constructors: () => ({
2021 new: [Completer$(T), []],
2022 sync: [Completer$(T), []]
2023 })
2024 });
2025 return Completer;
2026 });
2027 let Completer = Completer$();
2028 function _completeWithErrorCallback(result, error, stackTrace) {
2029 let replacement = Zone.current.errorCallback(error, dart.as(stackTrace, core .StackTrace));
2030 if (replacement != null) {
2031 error = _nonNullError(replacement.error);
2032 stackTrace = replacement.stackTrace;
2033 }
2034 result[_completeError](error, dart.as(stackTrace, core.StackTrace));
2035 }
2036 dart.fn(_completeWithErrorCallback, () => dart.definiteFunctionType(dart.void, [_Future, dart.dynamic, dart.dynamic]));
2037 function _nonNullError(error) {
2038 return error != null ? error : new core.NullThrownError();
2039 }
2040 dart.fn(_nonNullError, core.Object, [core.Object]);
2041 let __CastType4 = dart.typedef('__CastType4', () => dart.functionType(dart.dyn amic, [dart.dynamic]));
2042 let _FutureOnValue$ = dart.generic(function(T) {
2043 let _FutureOnValue = dart.typedef('_FutureOnValue', () => dart.functionType( dart.dynamic, [T]));
2044 return _FutureOnValue;
2045 });
2046 let _FutureOnValue = _FutureOnValue$();
2047 let _FutureErrorTest = dart.typedef('_FutureErrorTest', () => dart.functionTyp e(core.bool, [dart.dynamic]));
2048 let _FutureAction = dart.typedef('_FutureAction', () => dart.functionType(dart .dynamic, []));
2049 let _Completer$ = dart.generic(function(T) {
2050 class _Completer extends core.Object {
2051 _Completer() {
2052 this.future = new (_Future$(T))();
2053 }
2054 completeError(error, stackTrace) {
2055 if (stackTrace === void 0)
2056 stackTrace = null;
2057 error = _nonNullError(error);
2058 if (!dart.notNull(this.future[_mayComplete]))
2059 dart.throw(new core.StateError("Future already completed"));
2060 let replacement = Zone.current.errorCallback(error, stackTrace);
2061 if (replacement != null) {
2062 error = _nonNullError(replacement.error);
2063 stackTrace = replacement.stackTrace;
2064 }
2065 this[_completeError](error, stackTrace);
2066 }
2067 get isCompleted() {
2068 return !dart.notNull(this.future[_mayComplete]);
2069 }
2070 }
2071 _Completer[dart.implements] = () => [Completer$(T)];
2072 dart.setSignature(_Completer, {
2073 methods: () => ({completeError: [dart.void, [core.Object], [core.StackTrac e]]})
2074 });
2075 return _Completer;
2076 });
2077 let _Completer = _Completer$();
2078 let _asyncCompleteError = Symbol('_asyncCompleteError');
2079 let _AsyncCompleter$ = dart.generic(function(T) {
2080 class _AsyncCompleter extends _Completer$(T) {
2081 _AsyncCompleter() {
2082 super._Completer();
2083 }
2084 complete(value) {
2085 if (value === void 0)
2086 value = null;
2087 if (!dart.notNull(this.future[_mayComplete]))
2088 dart.throw(new core.StateError("Future already completed"));
2089 this.future[_asyncComplete](value);
2090 }
2091 [_completeError](error, stackTrace) {
2092 this.future[_asyncCompleteError](error, stackTrace);
2093 }
2094 }
2095 dart.setSignature(_AsyncCompleter, {
2096 methods: () => ({
2097 complete: [dart.void, [], [dart.dynamic]],
2098 [_completeError]: [dart.void, [core.Object, core.StackTrace]]
2099 })
2100 });
2101 return _AsyncCompleter;
2102 });
2103 let _AsyncCompleter = _AsyncCompleter$();
2104 let _SyncCompleter$ = dart.generic(function(T) {
2105 class _SyncCompleter extends _Completer$(T) {
2106 _SyncCompleter() {
2107 super._Completer();
2108 }
2109 complete(value) {
2110 if (value === void 0)
2111 value = null;
2112 if (!dart.notNull(this.future[_mayComplete]))
2113 dart.throw(new core.StateError("Future already completed"));
2114 this.future[_complete](value);
2115 }
2116 [_completeError](error, stackTrace) {
2117 this.future[_completeError](error, stackTrace);
2118 }
2119 }
2120 dart.setSignature(_SyncCompleter, {
2121 methods: () => ({
2122 complete: [dart.void, [], [dart.dynamic]],
2123 [_completeError]: [dart.void, [core.Object, core.StackTrace]]
2124 })
2125 });
2126 return _SyncCompleter;
2127 });
2128 let _SyncCompleter = _SyncCompleter$();
2129 let _nextListener = Symbol('_nextListener');
2130 let _onValue = Symbol('_onValue');
2131 let _errorTest = Symbol('_errorTest');
2132 let _whenCompleteAction = Symbol('_whenCompleteAction');
2133 class _FutureListener extends core.Object {
2134 then(result, onValue, errorCallback) {
2135 this.result = result;
2136 this.callback = onValue;
2137 this.errorCallback = errorCallback;
2138 this.state = errorCallback == null ? _FutureListener.STATE_THEN : _FutureL istener.STATE_THEN_ONERROR;
2139 this[_nextListener] = null;
2140 }
2141 catchError(result, errorCallback, test) {
2142 this.result = result;
2143 this.errorCallback = errorCallback;
2144 this.callback = test;
2145 this.state = test == null ? _FutureListener.STATE_CATCHERROR : _FutureList ener.STATE_CATCHERROR_TEST;
2146 this[_nextListener] = null;
2147 }
2148 whenComplete(result, onComplete) {
2149 this.result = result;
2150 this.callback = onComplete;
2151 this.errorCallback = null;
2152 this.state = _FutureListener.STATE_WHENCOMPLETE;
2153 this[_nextListener] = null;
2154 }
2155 chain(result) {
2156 this.result = result;
2157 this.callback = null;
2158 this.errorCallback = null;
2159 this.state = _FutureListener.STATE_CHAIN;
2160 this[_nextListener] = null;
2161 }
2162 get [_zone]() {
2163 return this.result[_zone];
2164 }
2165 get handlesValue() {
2166 return (dart.notNull(this.state) & dart.notNull(_FutureListener.MASK_VALUE )) != 0;
2167 }
2168 get handlesError() {
2169 return (dart.notNull(this.state) & dart.notNull(_FutureListener.MASK_ERROR )) != 0;
2170 }
2171 get hasErrorTest() {
2172 return this.state == _FutureListener.STATE_CATCHERROR_TEST;
2173 }
2174 get handlesComplete() {
2175 return this.state == _FutureListener.STATE_WHENCOMPLETE;
2176 }
2177 get [_onValue]() {
2178 dart.assert(this.handlesValue);
2179 return dart.as(this.callback, _FutureOnValue);
2180 }
2181 get [_onError]() {
2182 return this.errorCallback;
2183 }
2184 get [_errorTest]() {
2185 dart.assert(this.hasErrorTest);
2186 return dart.as(this.callback, _FutureErrorTest);
2187 }
2188 get [_whenCompleteAction]() {
2189 dart.assert(this.handlesComplete);
2190 return dart.as(this.callback, _FutureAction);
2191 }
2192 }
2193 dart.defineNamedConstructor(_FutureListener, 'then');
2194 dart.defineNamedConstructor(_FutureListener, 'catchError');
2195 dart.defineNamedConstructor(_FutureListener, 'whenComplete');
2196 dart.defineNamedConstructor(_FutureListener, 'chain');
2197 dart.setSignature(_FutureListener, {
2198 constructors: () => ({
2199 then: [_FutureListener, [_Future, _FutureOnValue, core.Function]],
2200 catchError: [_FutureListener, [_Future, core.Function, _FutureErrorTest]],
2201 whenComplete: [_FutureListener, [_Future, _FutureAction]],
2202 chain: [_FutureListener, [_Future]]
2203 })
2204 });
2205 _FutureListener.MASK_VALUE = 1;
2206 _FutureListener.MASK_ERROR = 2;
2207 _FutureListener.MASK_TEST_ERROR = 4;
2208 _FutureListener.MASK_WHENCOMPLETE = 8;
2209 _FutureListener.STATE_CHAIN = 0;
2210 _FutureListener.STATE_THEN = _FutureListener.MASK_VALUE;
2211 _FutureListener.STATE_THEN_ONERROR = dart.notNull(_FutureListener.MASK_VALUE) | dart.notNull(_FutureListener.MASK_ERROR);
2212 _FutureListener.STATE_CATCHERROR = _FutureListener.MASK_ERROR;
2213 _FutureListener.STATE_CATCHERROR_TEST = dart.notNull(_FutureListener.MASK_ERRO R) | dart.notNull(_FutureListener.MASK_TEST_ERROR);
2214 _FutureListener.STATE_WHENCOMPLETE = _FutureListener.MASK_WHENCOMPLETE;
2215 let _resultOrListeners = Symbol('_resultOrListeners');
2216 let _isChained = Symbol('_isChained');
2217 let _isComplete = Symbol('_isComplete');
2218 let _hasValue = Symbol('_hasValue');
2219 let _hasError = Symbol('_hasError');
2220 let _markPendingCompletion = Symbol('_markPendingCompletion');
2221 let _value = Symbol('_value');
2222 let _error = Symbol('_error');
2223 let _setValue = Symbol('_setValue');
2224 let _setErrorObject = Symbol('_setErrorObject');
2225 let _setError = Symbol('_setError');
2226 let _removeListeners = Symbol('_removeListeners');
2227 let _Future$ = dart.generic(function(T) {
2228 class _Future extends core.Object {
2229 _Future() {
2230 this[_zone] = Zone.current;
2231 this[_state] = _Future$()._INCOMPLETE;
2232 this[_resultOrListeners] = null;
2233 }
2234 immediate(value) {
2235 this[_zone] = Zone.current;
2236 this[_state] = _Future$()._INCOMPLETE;
2237 this[_resultOrListeners] = null;
2238 this[_asyncComplete](value);
2239 }
2240 immediateError(error, stackTrace) {
2241 if (stackTrace === void 0)
2242 stackTrace = null;
2243 this[_zone] = Zone.current;
2244 this[_state] = _Future$()._INCOMPLETE;
2245 this[_resultOrListeners] = null;
2246 this[_asyncCompleteError](error, stackTrace);
2247 }
2248 get [_mayComplete]() {
2249 return this[_state] == _Future$()._INCOMPLETE;
2250 }
2251 get [_isChained]() {
2252 return this[_state] == _Future$()._CHAINED;
2253 }
2254 get [_isComplete]() {
2255 return dart.notNull(this[_state]) >= dart.notNull(_Future$()._VALUE);
2256 }
2257 get [_hasValue]() {
2258 return this[_state] == _Future$()._VALUE;
2259 }
2260 get [_hasError]() {
2261 return this[_state] == _Future$()._ERROR;
2262 }
2263 set [_isChained](value) {
2264 if (dart.notNull(value)) {
2265 dart.assert(!dart.notNull(this[_isComplete]));
2266 this[_state] = _Future$()._CHAINED;
2267 } else {
2268 dart.assert(this[_isChained]);
2269 this[_state] = _Future$()._INCOMPLETE;
2270 }
2271 }
2272 then(f, opts) {
2273 dart.as(f, dart.functionType(dart.dynamic, [T]));
2274 let onError = opts && 'onError' in opts ? opts.onError : null;
2275 let result = new (_Future$())();
2276 if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
2277 f = dart.as(result[_zone].registerUnaryCallback(f), __CastType6);
2278 if (onError != null) {
2279 onError = _registerErrorHandler(onError, result[_zone]);
2280 }
2281 }
2282 this[_addListener](new _FutureListener.then(result, f, onError));
2283 return result;
2284 }
2285 catchError(onError, opts) {
2286 let test = opts && 'test' in opts ? opts.test : null;
2287 dart.as(test, dart.functionType(core.bool, [dart.dynamic]));
2288 let result = new (_Future$())();
2289 if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
2290 onError = _registerErrorHandler(onError, result[_zone]);
2291 if (test != null)
2292 test = dart.as(result[_zone].registerUnaryCallback(test), __CastType 8);
2293 }
2294 this[_addListener](new _FutureListener.catchError(result, onError, test) );
2295 return result;
2296 }
2297 whenComplete(action) {
2298 dart.as(action, dart.functionType(dart.dynamic, []));
2299 let result = new (_Future$(T))();
2300 if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
2301 action = result[_zone].registerCallback(action);
2302 }
2303 this[_addListener](new _FutureListener.whenComplete(result, action));
2304 return dart.as(result, Future$(T));
2305 }
2306 asStream() {
2307 return Stream$(T).fromFuture(this);
2308 }
2309 [_markPendingCompletion]() {
2310 if (!dart.notNull(this[_mayComplete]))
2311 dart.throw(new core.StateError("Future already completed"));
2312 this[_state] = _Future$()._PENDING_COMPLETE;
2313 }
2314 get [_value]() {
2315 dart.assert(dart.notNull(this[_isComplete]) && dart.notNull(this[_hasVal ue]));
2316 return dart.as(this[_resultOrListeners], T);
2317 }
2318 get [_error]() {
2319 dart.assert(dart.notNull(this[_isComplete]) && dart.notNull(this[_hasErr or]));
2320 return dart.as(this[_resultOrListeners], AsyncError);
2321 }
2322 [_setValue](value) {
2323 dart.as(value, T);
2324 dart.assert(!dart.notNull(this[_isComplete]));
2325 this[_state] = _Future$()._VALUE;
2326 this[_resultOrListeners] = value;
2327 }
2328 [_setErrorObject](error) {
2329 dart.assert(!dart.notNull(this[_isComplete]));
2330 this[_state] = _Future$()._ERROR;
2331 this[_resultOrListeners] = error;
2332 }
2333 [_setError](error, stackTrace) {
2334 this[_setErrorObject](new AsyncError(error, stackTrace));
2335 }
2336 [_addListener](listener) {
2337 dart.assert(listener[_nextListener] == null);
2338 if (dart.notNull(this[_isComplete])) {
2339 this[_zone].scheduleMicrotask(dart.fn((() => {
2340 _Future$()._propagateToListeners(this, listener);
2341 }).bind(this)));
2342 } else {
2343 listener[_nextListener] = dart.as(this[_resultOrListeners], _FutureLis tener);
2344 this[_resultOrListeners] = listener;
2345 }
2346 }
2347 [_removeListeners]() {
2348 dart.assert(!dart.notNull(this[_isComplete]));
2349 let current = dart.as(this[_resultOrListeners], _FutureListener);
2350 this[_resultOrListeners] = null;
2351 let prev = null;
2352 while (current != null) {
2353 let next = current[_nextListener];
2354 current[_nextListener] = prev;
2355 prev = current;
2356 current = next;
2357 }
2358 return prev;
2359 }
2360 static _chainForeignFuture(source, target) {
2361 dart.assert(!dart.notNull(target[_isComplete]));
2362 dart.assert(!dart.is(source, _Future$()));
2363 target[_isChained] = true;
2364 source.then(dart.fn(value => {
2365 dart.assert(target[_isChained]);
2366 target[_completeWithValue](value);
2367 }), {onError: dart.fn((error, stackTrace) => {
2368 if (stackTrace === void 0)
2369 stackTrace = null;
2370 dart.assert(target[_isChained]);
2371 target[_completeError](error, dart.as(stackTrace, core.StackTrace));
2372 }, dart.dynamic, [dart.dynamic], [dart.dynamic])});
2373 }
2374 static _chainCoreFuture(source, target) {
2375 dart.assert(!dart.notNull(target[_isComplete]));
2376 dart.assert(dart.is(source, _Future$()));
2377 target[_isChained] = true;
2378 let listener = new _FutureListener.chain(target);
2379 if (dart.notNull(source[_isComplete])) {
2380 _Future$()._propagateToListeners(source, listener);
2381 } else {
2382 source[_addListener](listener);
2383 }
2384 }
2385 [_complete](value) {
2386 dart.assert(!dart.notNull(this[_isComplete]));
2387 if (dart.is(value, Future)) {
2388 if (dart.is(value, _Future$())) {
2389 _Future$()._chainCoreFuture(dart.as(value, _Future$()), this);
2390 } else {
2391 _Future$()._chainForeignFuture(dart.as(value, Future), this);
2392 }
2393 } else {
2394 let listeners = this[_removeListeners]();
2395 this[_setValue](dart.as(value, T));
2396 _Future$()._propagateToListeners(this, listeners);
2397 }
2398 }
2399 [_completeWithValue](value) {
2400 dart.assert(!dart.notNull(this[_isComplete]));
2401 dart.assert(!dart.is(value, Future));
2402 let listeners = this[_removeListeners]();
2403 this[_setValue](dart.as(value, T));
2404 _Future$()._propagateToListeners(this, listeners);
2405 }
2406 [_completeError](error, stackTrace) {
2407 if (stackTrace === void 0)
2408 stackTrace = null;
2409 dart.assert(!dart.notNull(this[_isComplete]));
2410 let listeners = this[_removeListeners]();
2411 this[_setError](error, stackTrace);
2412 _Future$()._propagateToListeners(this, listeners);
2413 }
2414 [_asyncComplete](value) {
2415 dart.assert(!dart.notNull(this[_isComplete]));
2416 if (value == null) {
2417 } else if (dart.is(value, Future)) {
2418 let typedFuture = dart.as(value, Future$(T));
2419 if (dart.is(typedFuture, _Future$())) {
2420 let coreFuture = dart.as(typedFuture, _Future$(T));
2421 if (dart.notNull(coreFuture[_isComplete]) && dart.notNull(coreFuture [_hasError])) {
2422 this[_markPendingCompletion]();
2423 this[_zone].scheduleMicrotask(dart.fn((() => {
2424 _Future$()._chainCoreFuture(coreFuture, this);
2425 }).bind(this)));
2426 } else {
2427 _Future$()._chainCoreFuture(coreFuture, this);
2428 }
2429 } else {
2430 _Future$()._chainForeignFuture(typedFuture, this);
2431 }
2432 return;
2433 } else {
2434 let typedValue = dart.as(value, T);
2435 }
2436 this[_markPendingCompletion]();
2437 this[_zone].scheduleMicrotask(dart.fn((() => {
2438 this[_completeWithValue](value);
2439 }).bind(this)));
2440 }
2441 [_asyncCompleteError](error, stackTrace) {
2442 dart.assert(!dart.notNull(this[_isComplete]));
2443 this[_markPendingCompletion]();
2444 this[_zone].scheduleMicrotask(dart.fn((() => {
2445 this[_completeError](error, stackTrace);
2446 }).bind(this)));
2447 }
2448 static _propagateToListeners(source, listeners) {
2449 while (true) {
2450 dart.assert(source[_isComplete]);
2451 let hasError = source[_hasError];
2452 if (listeners == null) {
2453 if (dart.notNull(hasError)) {
2454 let asyncError = source[_error];
2455 source[_zone].handleUncaughtError(asyncError.error, asyncError.sta ckTrace);
2456 }
2457 return;
2458 }
2459 while (listeners[_nextListener] != null) {
2460 let listener = listeners;
2461 listeners = listener[_nextListener];
2462 listener[_nextListener] = null;
2463 _Future$()._propagateToListeners(source, listener);
2464 }
2465 let listener = listeners;
2466 let listenerHasValue = true;
2467 let sourceValue = dart.notNull(hasError) ? null : source[_value];
2468 let listenerValueOrError = sourceValue;
2469 let isPropagationAborted = false;
2470 if (dart.notNull(hasError) || dart.notNull(listener.handlesValue) || d art.notNull(listener.handlesComplete)) {
2471 let zone = listener[_zone];
2472 if (dart.notNull(hasError) && !dart.notNull(source[_zone].inSameErro rZone(zone))) {
2473 let asyncError = source[_error];
2474 source[_zone].handleUncaughtError(asyncError.error, asyncError.sta ckTrace);
2475 return;
2476 }
2477 let oldZone = null;
2478 if (!dart.notNull(core.identical(Zone.current, zone))) {
2479 oldZone = Zone._enter(zone);
2480 }
2481 function handleValueCallback() {
2482 try {
2483 listenerValueOrError = zone.runUnary(listener[_onValue], sourceV alue);
2484 return true;
2485 } catch (e) {
2486 let s = dart.stackTrace(e);
2487 listenerValueOrError = new AsyncError(e, s);
2488 return false;
2489 }
2490
2491 }
2492 dart.fn(handleValueCallback, core.bool, []);
2493 function handleError() {
2494 let asyncError = source[_error];
2495 let matchesTest = true;
2496 if (dart.notNull(listener.hasErrorTest)) {
2497 let test = listener[_errorTest];
2498 try {
2499 matchesTest = dart.as(zone.runUnary(test, asyncError.error), c ore.bool);
2500 } catch (e) {
2501 let s = dart.stackTrace(e);
2502 listenerValueOrError = dart.notNull(core.identical(asyncError. error, e)) ? asyncError : new AsyncError(e, s);
2503 listenerHasValue = false;
2504 return;
2505 }
2506
2507 }
2508 let errorCallback = listener[_onError];
2509 if (dart.notNull(matchesTest) && errorCallback != null) {
2510 try {
2511 if (dart.is(errorCallback, ZoneBinaryCallback)) {
2512 listenerValueOrError = zone.runBinary(errorCallback, asyncEr ror.error, asyncError.stackTrace);
2513 } else {
2514 listenerValueOrError = zone.runUnary(dart.as(errorCallback, __CastType10), asyncError.error);
2515 }
2516 } catch (e) {
2517 let s = dart.stackTrace(e);
2518 listenerValueOrError = dart.notNull(core.identical(asyncError. error, e)) ? asyncError : new AsyncError(e, s);
2519 listenerHasValue = false;
2520 return;
2521 }
2522
2523 listenerHasValue = true;
2524 } else {
2525 listenerValueOrError = asyncError;
2526 listenerHasValue = false;
2527 }
2528 }
2529 dart.fn(handleError, dart.void, []);
2530 function handleWhenCompleteCallback() {
2531 let completeResult = null;
2532 try {
2533 completeResult = zone.run(listener[_whenCompleteAction]);
2534 } catch (e) {
2535 let s = dart.stackTrace(e);
2536 if (dart.notNull(hasError) && dart.notNull(core.identical(source [_error].error, e))) {
2537 listenerValueOrError = source[_error];
2538 } else {
2539 listenerValueOrError = new AsyncError(e, s);
2540 }
2541 listenerHasValue = false;
2542 return;
2543 }
2544
2545 if (dart.is(completeResult, Future)) {
2546 let result = listener.result;
2547 result[_isChained] = true;
2548 isPropagationAborted = true;
2549 dart.dsend(completeResult, 'then', dart.fn(ignored => {
2550 _Future$()._propagateToListeners(source, new _FutureListener.c hain(result));
2551 }), {onError: dart.fn((error, stackTrace) => {
2552 if (stackTrace === void 0)
2553 stackTrace = null;
2554 if (!dart.is(completeResult, _Future$())) {
2555 completeResult = new (_Future$())();
2556 dart.dsend(completeResult, _setError, error, stackTrace);
2557 }
2558 _Future$()._propagateToListeners(dart.as(completeResult, _Fu ture$()), new _FutureListener.chain(result));
2559 }, dart.dynamic, [dart.dynamic], [dart.dynamic])});
2560 }
2561 }
2562 dart.fn(handleWhenCompleteCallback, dart.void, []);
2563 if (!dart.notNull(hasError)) {
2564 if (dart.notNull(listener.handlesValue)) {
2565 listenerHasValue = handleValueCallback();
2566 }
2567 } else {
2568 handleError();
2569 }
2570 if (dart.notNull(listener.handlesComplete)) {
2571 handleWhenCompleteCallback();
2572 }
2573 if (oldZone != null)
2574 Zone._leave(oldZone);
2575 if (dart.notNull(isPropagationAborted))
2576 return;
2577 if (dart.notNull(listenerHasValue) && !dart.notNull(core.identical(s ourceValue, listenerValueOrError)) && dart.is(listenerValueOrError, Future)) {
2578 let chainSource = dart.as(listenerValueOrError, Future);
2579 let result = listener.result;
2580 if (dart.is(chainSource, _Future$())) {
2581 if (dart.notNull(chainSource[_isComplete])) {
2582 result[_isChained] = true;
2583 source = chainSource;
2584 listeners = new _FutureListener.chain(result);
2585 continue;
2586 } else {
2587 _Future$()._chainCoreFuture(chainSource, result);
2588 }
2589 } else {
2590 _Future$()._chainForeignFuture(chainSource, result);
2591 }
2592 return;
2593 }
2594 }
2595 let result = listener.result;
2596 listeners = result[_removeListeners]();
2597 if (dart.notNull(listenerHasValue)) {
2598 result[_setValue](listenerValueOrError);
2599 } else {
2600 let asyncError = dart.as(listenerValueOrError, AsyncError);
2601 result[_setErrorObject](asyncError);
2602 }
2603 source = result;
2604 }
2605 }
2606 timeout(timeLimit, opts) {
2607 let onTimeout = opts && 'onTimeout' in opts ? opts.onTimeout : null;
2608 dart.as(onTimeout, dart.functionType(dart.dynamic, []));
2609 if (dart.notNull(this[_isComplete]))
2610 return new (_Future$()).immediate(this);
2611 let result = new (_Future$())();
2612 let timer = null;
2613 if (onTimeout == null) {
2614 timer = Timer.new(timeLimit, dart.fn(() => {
2615 result[_completeError](new TimeoutException("Future not completed", timeLimit));
2616 }));
2617 } else {
2618 let zone = Zone.current;
2619 onTimeout = zone.registerCallback(onTimeout);
2620 timer = Timer.new(timeLimit, dart.fn(() => {
2621 try {
2622 result[_complete](zone.run(onTimeout));
2623 } catch (e) {
2624 let s = dart.stackTrace(e);
2625 result[_completeError](e, s);
2626 }
2627
2628 }));
2629 }
2630 this.then(dart.fn(v => {
2631 dart.as(v, T);
2632 if (dart.notNull(timer.isActive)) {
2633 timer.cancel();
2634 result[_completeWithValue](v);
2635 }
2636 }, dart.dynamic, [T]), {onError: dart.fn((e, s) => {
2637 if (dart.notNull(timer.isActive)) {
2638 timer.cancel();
2639 result[_completeError](e, dart.as(s, core.StackTrace));
2640 }
2641 })});
2642 return result;
2643 }
2644 }
2645 _Future[dart.implements] = () => [Future$(T)];
2646 dart.defineNamedConstructor(_Future, 'immediate');
2647 dart.defineNamedConstructor(_Future, 'immediateError');
2648 dart.setSignature(_Future, {
2649 constructors: () => ({
2650 _Future: [_Future$(T), []],
2651 immediate: [_Future$(T), [dart.dynamic]],
2652 immediateError: [_Future$(T), [dart.dynamic], [core.StackTrace]]
2653 }),
2654 methods: () => ({
2655 then: [Future, [dart.functionType(dart.dynamic, [T])], {onError: core.Fu nction}],
2656 catchError: [Future, [core.Function], {test: dart.functionType(core.bool , [dart.dynamic])}],
2657 whenComplete: [Future$(T), [dart.functionType(dart.dynamic, [])]],
2658 asStream: [Stream$(T), []],
2659 [_markPendingCompletion]: [dart.void, []],
2660 [_setValue]: [dart.void, [T]],
2661 [_setErrorObject]: [dart.void, [AsyncError]],
2662 [_setError]: [dart.void, [core.Object, core.StackTrace]],
2663 [_addListener]: [dart.void, [_FutureListener]],
2664 [_removeListeners]: [_FutureListener, []],
2665 [_complete]: [dart.void, [dart.dynamic]],
2666 [_completeWithValue]: [dart.void, [dart.dynamic]],
2667 [_completeError]: [dart.void, [dart.dynamic], [core.StackTrace]],
2668 [_asyncComplete]: [dart.void, [dart.dynamic]],
2669 [_asyncCompleteError]: [dart.void, [dart.dynamic, core.StackTrace]],
2670 timeout: [Future, [core.Duration], {onTimeout: dart.functionType(dart.dy namic, [])}]
2671 }),
2672 statics: () => ({
2673 _chainForeignFuture: [dart.void, [Future, _Future$()]],
2674 _chainCoreFuture: [dart.void, [_Future$(), _Future$()]],
2675 _propagateToListeners: [dart.void, [_Future$(), _FutureListener]]
2676 }),
2677 names: ['_chainForeignFuture', '_chainCoreFuture', '_propagateToListeners' ]
2678 });
2679 return _Future;
2680 });
2681 let _Future = _Future$();
2682 _Future._INCOMPLETE = 0;
2683 _Future._PENDING_COMPLETE = 1;
2684 _Future._CHAINED = 2;
2685 _Future._VALUE = 4;
2686 _Future._ERROR = 8;
2687 let __CastType6$ = dart.generic(function(T) {
2688 let __CastType6 = dart.typedef('__CastType6', () => dart.functionType(dart.d ynamic, [T]));
2689 return __CastType6;
2690 });
2691 let __CastType6 = __CastType6$();
2692 let __CastType8 = dart.typedef('__CastType8', () => dart.functionType(core.boo l, [dart.dynamic]));
2693 let __CastType10 = dart.typedef('__CastType10', () => dart.functionType(dart.d ynamic, [dart.dynamic]));
2694 let _AsyncCallback = dart.typedef('_AsyncCallback', () => dart.functionType(da rt.void, []));
2695 class _AsyncCallbackEntry extends core.Object {
2696 _AsyncCallbackEntry(callback) {
2697 this.callback = callback;
2698 this.next = null;
2699 }
2700 }
2701 dart.setSignature(_AsyncCallbackEntry, {
2702 constructors: () => ({_AsyncCallbackEntry: [_AsyncCallbackEntry, [_AsyncCall back]]})
2703 });
2704 exports._nextCallback = null;
2705 exports._lastCallback = null;
2706 exports._lastPriorityCallback = null;
2707 exports._isInCallbackLoop = false;
2708 function _asyncRunCallbackLoop() {
2709 while (exports._nextCallback != null) {
2710 exports._lastPriorityCallback = null;
2711 let entry = exports._nextCallback;
2712 exports._nextCallback = entry.next;
2713 if (exports._nextCallback == null)
2714 exports._lastCallback = null;
2715 entry.callback();
2716 }
2717 }
2718 dart.fn(_asyncRunCallbackLoop, dart.void, []);
2719 function _asyncRunCallback() {
2720 exports._isInCallbackLoop = true;
2721 try {
2722 _asyncRunCallbackLoop();
2723 } finally {
2724 exports._lastPriorityCallback = null;
2725 exports._isInCallbackLoop = false;
2726 if (exports._nextCallback != null)
2727 _AsyncRun._scheduleImmediate(_asyncRunCallback);
2728 }
2729 }
2730 dart.fn(_asyncRunCallback, dart.void, []);
2731 function _scheduleAsyncCallback(callback) {
2732 if (exports._nextCallback == null) {
2733 exports._nextCallback = exports._lastCallback = new _AsyncCallbackEntry(da rt.as(callback, _AsyncCallback));
2734 if (!dart.notNull(exports._isInCallbackLoop)) {
2735 _AsyncRun._scheduleImmediate(_asyncRunCallback);
2736 }
2737 } else {
2738 let newEntry = new _AsyncCallbackEntry(dart.as(callback, _AsyncCallback));
2739 exports._lastCallback.next = newEntry;
2740 exports._lastCallback = newEntry;
2741 }
2742 }
2743 dart.fn(_scheduleAsyncCallback, dart.void, [dart.dynamic]);
2744 function _schedulePriorityAsyncCallback(callback) {
2745 let entry = new _AsyncCallbackEntry(dart.as(callback, _AsyncCallback));
2746 if (exports._nextCallback == null) {
2747 _scheduleAsyncCallback(callback);
2748 exports._lastPriorityCallback = exports._lastCallback;
2749 } else if (exports._lastPriorityCallback == null) {
2750 entry.next = exports._nextCallback;
2751 exports._nextCallback = exports._lastPriorityCallback = entry;
2752 } else {
2753 entry.next = exports._lastPriorityCallback.next;
2754 exports._lastPriorityCallback.next = entry;
2755 exports._lastPriorityCallback = entry;
2756 if (entry.next == null) {
2757 exports._lastCallback = entry;
2758 }
2759 }
2760 }
2761 dart.fn(_schedulePriorityAsyncCallback, dart.void, [dart.dynamic]);
2762 function scheduleMicrotask(callback) {
2763 if (dart.notNull(core.identical(_ROOT_ZONE, Zone.current))) {
2764 _rootScheduleMicrotask(null, null, _ROOT_ZONE, callback);
2765 return;
2766 }
2767 Zone.current.scheduleMicrotask(Zone.current.bindCallback(callback, {runGuard ed: true}));
2768 }
2769 dart.fn(scheduleMicrotask, dart.void, [dart.functionType(dart.void, [])]);
2770 class _AsyncRun extends core.Object {
2771 static _scheduleImmediate(callback) {
2772 dart.dcall(_AsyncRun.scheduleImmediateClosure, callback);
2773 }
2774 static _initializeScheduleImmediate() {
2775 if (self.scheduleImmediate != null) {
2776 return _AsyncRun._scheduleImmediateJsOverride;
2777 }
2778 if (self.MutationObserver != null && self.document != null) {
2779 let div = self.document.createElement("div");
2780 let span = self.document.createElement("span");
2781 let storedCallback = null;
2782 function internalCallback(_) {
2783 _isolate_helper.leaveJsAsync();
2784 let f = storedCallback;
2785 storedCallback = null;
2786 dart.dcall(f);
2787 }
2788 dart.fn(internalCallback);
2789 ;
2790 let observer = new self.MutationObserver(internalCallback);
2791 observer.observe(div, {childList: true});
2792 return dart.fn(callback => {
2793 dart.assert(storedCallback == null);
2794 _isolate_helper.enterJsAsync();
2795 storedCallback = callback;
2796 div.firstChild ? div.removeChild(span) : div.appendChild(span);
2797 }, dart.dynamic, [dart.functionType(dart.void, [])]);
2798 } else if (self.setImmediate != null) {
2799 return _AsyncRun._scheduleImmediateWithSetImmediate;
2800 }
2801 return _AsyncRun._scheduleImmediateWithTimer;
2802 }
2803 static _scheduleImmediateJsOverride(callback) {
2804 function internalCallback() {
2805 _isolate_helper.leaveJsAsync();
2806 callback();
2807 }
2808 dart.fn(internalCallback);
2809 ;
2810 _isolate_helper.enterJsAsync();
2811 self.scheduleImmediate(internalCallback);
2812 }
2813 static _scheduleImmediateWithSetImmediate(callback) {
2814 function internalCallback() {
2815 _isolate_helper.leaveJsAsync();
2816 callback();
2817 }
2818 dart.fn(internalCallback);
2819 ;
2820 _isolate_helper.enterJsAsync();
2821 self.setImmediate(internalCallback);
2822 }
2823 static _scheduleImmediateWithTimer(callback) {
2824 Timer._createTimer(core.Duration.ZERO, callback);
2825 }
2826 }
2827 dart.setSignature(_AsyncRun, {
2828 statics: () => ({
2829 _scheduleImmediate: [dart.void, [dart.functionType(dart.void, [])]],
2830 _initializeScheduleImmediate: [core.Function, []],
2831 _scheduleImmediateJsOverride: [dart.void, [dart.functionType(dart.void, [] )]],
2832 _scheduleImmediateWithSetImmediate: [dart.void, [dart.functionType(dart.vo id, [])]],
2833 _scheduleImmediateWithTimer: [dart.void, [dart.functionType(dart.void, []) ]]
2834 }),
2835 names: ['_scheduleImmediate', '_initializeScheduleImmediate', '_scheduleImme diateJsOverride', '_scheduleImmediateWithSetImmediate', '_scheduleImmediateWithT imer']
2836 });
2837 dart.defineLazyProperties(_AsyncRun, {
2838 get scheduleImmediateClosure() {
2839 return _AsyncRun._initializeScheduleImmediate();
2840 }
2841 });
2842 let StreamSubscription$ = dart.generic(function(T) {
2843 class StreamSubscription extends core.Object {}
2844 return StreamSubscription;
2845 });
2846 let StreamSubscription = StreamSubscription$();
2847 let EventSink$ = dart.generic(function(T) {
2848 class EventSink extends core.Object {}
2849 EventSink[dart.implements] = () => [core.Sink$(T)];
2850 return EventSink;
2851 });
2852 let EventSink = EventSink$();
2853 let _stream = Symbol('_stream');
2854 let StreamView$ = dart.generic(function(T) {
2855 class StreamView extends Stream$(T) {
2856 StreamView(stream) {
2857 this[_stream] = stream;
2858 super.Stream();
2859 }
2860 get isBroadcast() {
2861 return this[_stream].isBroadcast;
2862 }
2863 asBroadcastStream(opts) {
2864 let onListen = opts && 'onListen' in opts ? opts.onListen : null;
2865 dart.as(onListen, dart.functionType(dart.void, [StreamSubscription$(T)]) );
2866 let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
2867 dart.as(onCancel, dart.functionType(dart.void, [StreamSubscription$(T)]) );
2868 return this[_stream].asBroadcastStream({onListen: onListen, onCancel: on Cancel});
2869 }
2870 listen(onData, opts) {
2871 dart.as(onData, dart.functionType(dart.void, [T]));
2872 let onError = opts && 'onError' in opts ? opts.onError : null;
2873 let onDone = opts && 'onDone' in opts ? opts.onDone : null;
2874 dart.as(onDone, dart.functionType(dart.void, []));
2875 let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
2876 return this[_stream].listen(onData, {onError: onError, onDone: onDone, c ancelOnError: cancelOnError});
2877 }
2878 }
2879 dart.setSignature(StreamView, {
2880 constructors: () => ({StreamView: [StreamView$(T), [Stream$(T)]]}),
2881 methods: () => ({
2882 asBroadcastStream: [Stream$(T), [], {onListen: dart.functionType(dart.vo id, [StreamSubscription$(T)]), onCancel: dart.functionType(dart.void, [StreamSub scription$(T)])}],
2883 listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {o nError: core.Function, onDone: dart.functionType(dart.void, []), cancelOnError: core.bool}]
2884 })
2885 });
2886 return StreamView;
2887 });
2888 let StreamView = StreamView$();
2889 let StreamConsumer$ = dart.generic(function(S) {
2890 class StreamConsumer extends core.Object {}
2891 return StreamConsumer;
2892 });
2893 let StreamConsumer = StreamConsumer$();
2894 let StreamSink$ = dart.generic(function(S) {
2895 class StreamSink extends core.Object {}
2896 StreamSink[dart.implements] = () => [StreamConsumer$(S), EventSink$(S)];
2897 return StreamSink;
2898 });
2899 let StreamSink = StreamSink$();
2900 let StreamTransformer$ = dart.generic(function(S, T) {
2901 class StreamTransformer extends core.Object {
2902 static new(transformer) {
2903 return new _StreamSubscriptionTransformer(transformer);
2904 }
2905 static fromHandlers(opts) {
2906 return new _StreamHandlerTransformer(opts);
2907 }
2908 }
2909 dart.setSignature(StreamTransformer, {
2910 constructors: () => ({
2911 new: [StreamTransformer$(S, T), [dart.functionType(StreamSubscription$(T ), [Stream$(S), core.bool])]],
2912 fromHandlers: [StreamTransformer$(S, T), [], {handleData: dart.functionT ype(dart.void, [S, EventSink$(T)]), handleError: dart.functionType(dart.void, [c ore.Object, core.StackTrace, EventSink$(T)]), handleDone: dart.functionType(dart .void, [EventSink$(T)])}]
2913 })
2914 });
2915 return StreamTransformer;
2916 });
2917 let StreamTransformer = StreamTransformer$();
2918 let StreamIterator$ = dart.generic(function(T) {
2919 class StreamIterator extends core.Object {
2920 static new(stream) {
2921 return new (_StreamIteratorImpl$(T))(stream);
2922 }
2923 }
2924 dart.setSignature(StreamIterator, {
2925 constructors: () => ({new: [StreamIterator$(T), [Stream$(T)]]})
2926 });
2927 return StreamIterator;
2928 });
2929 let StreamIterator = StreamIterator$();
2930 let _ControllerEventSinkWrapper$ = dart.generic(function(T) {
2931 class _ControllerEventSinkWrapper extends core.Object {
2932 _ControllerEventSinkWrapper(sink) {
2933 this[_sink] = sink;
2934 }
2935 add(data) {
2936 dart.as(data, T);
2937 this[_sink].add(data);
2938 }
2939 addError(error, stackTrace) {
2940 if (stackTrace === void 0)
2941 stackTrace = null;
2942 this[_sink].addError(error, stackTrace);
2943 }
2944 close() {
2945 this[_sink].close();
2946 }
2947 }
2948 _ControllerEventSinkWrapper[dart.implements] = () => [EventSink$(T)];
2949 dart.setSignature(_ControllerEventSinkWrapper, {
2950 constructors: () => ({_ControllerEventSinkWrapper: [_ControllerEventSinkWr apper$(T), [EventSink]]}),
2951 methods: () => ({
2952 add: [dart.void, [T]],
2953 addError: [dart.void, [dart.dynamic], [core.StackTrace]],
2954 close: [dart.void, []]
2955 })
2956 });
2957 return _ControllerEventSinkWrapper;
2958 });
2959 let _ControllerEventSinkWrapper = _ControllerEventSinkWrapper$();
2960 let __CastType12 = dart.typedef('__CastType12', () => dart.functionType(dart.v oid, [StreamSubscription]));
2961 let __CastType14 = dart.typedef('__CastType14', () => dart.functionType(dart.d ynamic, [dart.dynamic, core.StackTrace]));
2962 let __CastType17 = dart.typedef('__CastType17', () => dart.functionType(dart.v oid, []));
2963 let __CastType18 = dart.typedef('__CastType18', () => dart.functionType(dart.v oid, [EventSink]));
2964 let StreamController$ = dart.generic(function(T) {
2965 class StreamController extends core.Object {
2966 static new(opts) {
2967 let onListen = opts && 'onListen' in opts ? opts.onListen : null;
2968 let onPause = opts && 'onPause' in opts ? opts.onPause : null;
2969 let onResume = opts && 'onResume' in opts ? opts.onResume : null;
2970 let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
2971 let sync = opts && 'sync' in opts ? opts.sync : false;
2972 if (onListen == null && onPause == null && onResume == null && onCancel == null) {
2973 return dart.as(dart.notNull(sync) ? new _NoCallbackSyncStreamControlle r() : new _NoCallbackAsyncStreamController(), StreamController$(T));
2974 }
2975 return dart.notNull(sync) ? new (_SyncStreamController$(T))(onListen, on Pause, onResume, onCancel) : new (_AsyncStreamController$(T))(onListen, onPause, onResume, onCancel);
2976 }
2977 static broadcast(opts) {
2978 let onListen = opts && 'onListen' in opts ? opts.onListen : null;
2979 let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
2980 let sync = opts && 'sync' in opts ? opts.sync : false;
2981 return dart.notNull(sync) ? new (_SyncBroadcastStreamController$(T))(onL isten, onCancel) : new (_AsyncBroadcastStreamController$(T))(onListen, onCancel) ;
2982 }
2983 }
2984 StreamController[dart.implements] = () => [StreamSink$(T)];
2985 dart.setSignature(StreamController, {
2986 constructors: () => ({
2987 new: [StreamController$(T), [], {onListen: dart.functionType(dart.void, []), onPause: dart.functionType(dart.void, []), onResume: dart.functionType(dart .void, []), onCancel: dart.functionType(dart.dynamic, []), sync: core.bool}],
2988 broadcast: [StreamController$(T), [], {onListen: dart.functionType(dart. void, []), onCancel: dart.functionType(dart.void, []), sync: core.bool}]
2989 })
2990 });
2991 return StreamController;
2992 });
2993 let StreamController = StreamController$();
2994 let _StreamControllerLifecycle$ = dart.generic(function(T) {
2995 class _StreamControllerLifecycle extends core.Object {
2996 [_recordPause](subscription) {
2997 dart.as(subscription, StreamSubscription$(T));
2998 }
2999 [_recordResume](subscription) {
3000 dart.as(subscription, StreamSubscription$(T));
3001 }
3002 [_recordCancel](subscription) {
3003 dart.as(subscription, StreamSubscription$(T));
3004 return null;
3005 }
3006 }
3007 dart.setSignature(_StreamControllerLifecycle, {
3008 methods: () => ({
3009 [_recordPause]: [dart.void, [StreamSubscription$(T)]],
3010 [_recordResume]: [dart.void, [StreamSubscription$(T)]],
3011 [_recordCancel]: [Future, [StreamSubscription$(T)]]
3012 })
3013 });
3014 return _StreamControllerLifecycle;
3015 });
3016 let _StreamControllerLifecycle = _StreamControllerLifecycle$();
3017 let _varData = Symbol('_varData');
3018 let _isInitialState = Symbol('_isInitialState');
3019 let _subscription = Symbol('_subscription');
3020 let _pendingEvents = Symbol('_pendingEvents');
3021 let _ensurePendingEvents = Symbol('_ensurePendingEvents');
3022 let _badEventState = Symbol('_badEventState');
3023 let _StreamController$ = dart.generic(function(T) {
3024 class _StreamController extends core.Object {
3025 _StreamController() {
3026 this[_varData] = null;
3027 this[_state] = _StreamController$()._STATE_INITIAL;
3028 this[_doneFuture] = null;
3029 }
3030 get stream() {
3031 return new (_ControllerStream$(T))(this);
3032 }
3033 get sink() {
3034 return new (_StreamSinkWrapper$(T))(this);
3035 }
3036 get [_isCanceled]() {
3037 return (dart.notNull(this[_state]) & dart.notNull(_StreamController$()._ STATE_CANCELED)) != 0;
3038 }
3039 get hasListener() {
3040 return (dart.notNull(this[_state]) & dart.notNull(_StreamController$()._ STATE_SUBSCRIBED)) != 0;
3041 }
3042 get [_isInitialState]() {
3043 return (dart.notNull(this[_state]) & dart.notNull(_StreamController$()._ STATE_SUBSCRIPTION_MASK)) == _StreamController$()._STATE_INITIAL;
3044 }
3045 get isClosed() {
3046 return (dart.notNull(this[_state]) & dart.notNull(_StreamController$()._ STATE_CLOSED)) != 0;
3047 }
3048 get isPaused() {
3049 return dart.notNull(this.hasListener) ? this[_subscription][_isInputPaus ed] : !dart.notNull(this[_isCanceled]);
3050 }
3051 get [_isAddingStream]() {
3052 return (dart.notNull(this[_state]) & dart.notNull(_StreamController$()._ STATE_ADDSTREAM)) != 0;
3053 }
3054 get [_mayAddEvent]() {
3055 return dart.notNull(this[_state]) < dart.notNull(_StreamController$()._S TATE_CLOSED);
3056 }
3057 get [_pendingEvents]() {
3058 dart.assert(this[_isInitialState]);
3059 if (!dart.notNull(this[_isAddingStream])) {
3060 return dart.as(this[_varData], _PendingEvents);
3061 }
3062 let state = dart.as(this[_varData], _StreamControllerAddStreamState);
3063 return dart.as(state.varData, _PendingEvents);
3064 }
3065 [_ensurePendingEvents]() {
3066 dart.assert(this[_isInitialState]);
3067 if (!dart.notNull(this[_isAddingStream])) {
3068 if (this[_varData] == null)
3069 this[_varData] = new _StreamImplEvents();
3070 return dart.as(this[_varData], _StreamImplEvents);
3071 }
3072 let state = dart.as(this[_varData], _StreamControllerAddStreamState);
3073 if (state.varData == null)
3074 state.varData = new _StreamImplEvents();
3075 return dart.as(state.varData, _StreamImplEvents);
3076 }
3077 get [_subscription]() {
3078 dart.assert(this.hasListener);
3079 if (dart.notNull(this[_isAddingStream])) {
3080 let addState = dart.as(this[_varData], _StreamControllerAddStreamState );
3081 return dart.as(addState.varData, _ControllerSubscription);
3082 }
3083 return dart.as(this[_varData], _ControllerSubscription);
3084 }
3085 [_badEventState]() {
3086 if (dart.notNull(this.isClosed)) {
3087 return new core.StateError("Cannot add event after closing");
3088 }
3089 dart.assert(this[_isAddingStream]);
3090 return new core.StateError("Cannot add event while adding a stream");
3091 }
3092 addStream(source, opts) {
3093 dart.as(source, Stream$(T));
3094 let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : true;
3095 if (!dart.notNull(this[_mayAddEvent]))
3096 dart.throw(this[_badEventState]());
3097 if (dart.notNull(this[_isCanceled]))
3098 return new _Future.immediate(null);
3099 let addState = new _StreamControllerAddStreamState(this, this[_varData], source, cancelOnError);
3100 this[_varData] = addState;
3101 this[_state] = dart.notNull(this[_state]) | dart.notNull(_StreamControll er$()._STATE_ADDSTREAM);
3102 return addState.addStreamFuture;
3103 }
3104 get done() {
3105 return this[_ensureDoneFuture]();
3106 }
3107 [_ensureDoneFuture]() {
3108 if (this[_doneFuture] == null) {
3109 this[_doneFuture] = dart.notNull(this[_isCanceled]) ? Future._nullFutu re : new _Future();
3110 }
3111 return this[_doneFuture];
3112 }
3113 add(value) {
3114 dart.as(value, T);
3115 if (!dart.notNull(this[_mayAddEvent]))
3116 dart.throw(this[_badEventState]());
3117 this[_add](value);
3118 }
3119 addError(error, stackTrace) {
3120 if (stackTrace === void 0)
3121 stackTrace = null;
3122 error = _nonNullError(error);
3123 if (!dart.notNull(this[_mayAddEvent]))
3124 dart.throw(this[_badEventState]());
3125 let replacement = Zone.current.errorCallback(error, stackTrace);
3126 if (replacement != null) {
3127 error = _nonNullError(replacement.error);
3128 stackTrace = replacement.stackTrace;
3129 }
3130 this[_addError](error, stackTrace);
3131 }
3132 close() {
3133 if (dart.notNull(this.isClosed)) {
3134 return this[_ensureDoneFuture]();
3135 }
3136 if (!dart.notNull(this[_mayAddEvent]))
3137 dart.throw(this[_badEventState]());
3138 this[_closeUnchecked]();
3139 return this[_ensureDoneFuture]();
3140 }
3141 [_closeUnchecked]() {
3142 this[_state] = dart.notNull(this[_state]) | dart.notNull(_StreamControll er$()._STATE_CLOSED);
3143 if (dart.notNull(this.hasListener)) {
3144 this[_sendDone]();
3145 } else if (dart.notNull(this[_isInitialState])) {
3146 this[_ensurePendingEvents]().add(dart.const(new _DelayedDone()));
3147 }
3148 }
3149 [_add](value) {
3150 dart.as(value, T);
3151 if (dart.notNull(this.hasListener)) {
3152 this[_sendData](value);
3153 } else if (dart.notNull(this[_isInitialState])) {
3154 this[_ensurePendingEvents]().add(new (_DelayedData$(T))(value));
3155 }
3156 }
3157 [_addError](error, stackTrace) {
3158 if (dart.notNull(this.hasListener)) {
3159 this[_sendError](error, stackTrace);
3160 } else if (dart.notNull(this[_isInitialState])) {
3161 this[_ensurePendingEvents]().add(new _DelayedError(error, stackTrace)) ;
3162 }
3163 }
3164 [_close]() {
3165 dart.assert(this[_isAddingStream]);
3166 let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
3167 this[_varData] = addState.varData;
3168 this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_StreamControl ler$()._STATE_ADDSTREAM);
3169 addState.complete();
3170 }
3171 [_subscribe](onData, onError, onDone, cancelOnError) {
3172 dart.as(onData, dart.functionType(dart.void, [T]));
3173 dart.as(onDone, dart.functionType(dart.void, []));
3174 if (!dart.notNull(this[_isInitialState])) {
3175 dart.throw(new core.StateError("Stream has already been listened to.") );
3176 }
3177 let subscription = new _ControllerSubscription(this, onData, onError, on Done, cancelOnError);
3178 let pendingEvents = this[_pendingEvents];
3179 this[_state] = dart.notNull(this[_state]) | dart.notNull(_StreamControll er$()._STATE_SUBSCRIBED);
3180 if (dart.notNull(this[_isAddingStream])) {
3181 let addState = dart.as(this[_varData], _StreamControllerAddStreamState );
3182 addState.varData = subscription;
3183 addState.resume();
3184 } else {
3185 this[_varData] = subscription;
3186 }
3187 subscription[_setPendingEvents](pendingEvents);
3188 subscription[_guardCallback](dart.fn((() => {
3189 _runGuarded(this[_onListen]);
3190 }).bind(this)));
3191 return dart.as(subscription, StreamSubscription$(T));
3192 }
3193 [_recordCancel](subscription) {
3194 dart.as(subscription, StreamSubscription$(T));
3195 let result = null;
3196 if (dart.notNull(this[_isAddingStream])) {
3197 let addState = dart.as(this[_varData], _StreamControllerAddStreamState );
3198 result = addState.cancel();
3199 }
3200 this[_varData] = null;
3201 this[_state] = dart.notNull(this[_state]) & ~(dart.notNull(_StreamContro ller$()._STATE_SUBSCRIBED) | dart.notNull(_StreamController$()._STATE_ADDSTREAM) ) | dart.notNull(_StreamController$()._STATE_CANCELED);
3202 if (this[_onCancel] != null) {
3203 if (result == null) {
3204 try {
3205 result = dart.as(this[_onCancel](), Future);
3206 } catch (e) {
3207 let s = dart.stackTrace(e);
3208 result = new _Future();
3209 result[_asyncCompleteError](e, s);
3210 }
3211
3212 } else {
3213 result = result.whenComplete(this[_onCancel]);
3214 }
3215 }
3216 let complete = (function() {
3217 if (this[_doneFuture] != null && dart.notNull(this[_doneFuture][_mayCo mplete])) {
3218 this[_doneFuture][_asyncComplete](null);
3219 }
3220 }).bind(this);
3221 dart.fn(complete, dart.void, []);
3222 if (result != null) {
3223 result = result.whenComplete(complete);
3224 } else {
3225 complete();
3226 }
3227 return result;
3228 }
3229 [_recordPause](subscription) {
3230 dart.as(subscription, StreamSubscription$(T));
3231 if (dart.notNull(this[_isAddingStream])) {
3232 let addState = dart.as(this[_varData], _StreamControllerAddStreamState );
3233 addState.pause();
3234 }
3235 _runGuarded(this[_onPause]);
3236 }
3237 [_recordResume](subscription) {
3238 dart.as(subscription, StreamSubscription$(T));
3239 if (dart.notNull(this[_isAddingStream])) {
3240 let addState = dart.as(this[_varData], _StreamControllerAddStreamState );
3241 addState.resume();
3242 }
3243 _runGuarded(this[_onResume]);
3244 }
3245 }
3246 _StreamController[dart.implements] = () => [StreamController$(T), _StreamCon trollerLifecycle$(T), _EventSink$(T), _EventDispatch$(T)];
3247 dart.setSignature(_StreamController, {
3248 constructors: () => ({_StreamController: [_StreamController$(T), []]}),
3249 methods: () => ({
3250 [_ensurePendingEvents]: [_StreamImplEvents, []],
3251 [_badEventState]: [core.Error, []],
3252 addStream: [Future, [Stream$(T)], {cancelOnError: core.bool}],
3253 [_ensureDoneFuture]: [Future, []],
3254 add: [dart.void, [T]],
3255 addError: [dart.void, [core.Object], [core.StackTrace]],
3256 close: [Future, []],
3257 [_closeUnchecked]: [dart.void, []],
3258 [_add]: [dart.void, [T]],
3259 [_addError]: [dart.void, [core.Object, core.StackTrace]],
3260 [_close]: [dart.void, []],
3261 [_subscribe]: [StreamSubscription$(T), [dart.functionType(dart.void, [T] ), core.Function, dart.functionType(dart.void, []), core.bool]],
3262 [_recordCancel]: [Future, [StreamSubscription$(T)]],
3263 [_recordPause]: [dart.void, [StreamSubscription$(T)]],
3264 [_recordResume]: [dart.void, [StreamSubscription$(T)]]
3265 })
3266 });
3267 return _StreamController;
3268 });
3269 let _StreamController = _StreamController$();
3270 _StreamController._STATE_INITIAL = 0;
3271 _StreamController._STATE_SUBSCRIBED = 1;
3272 _StreamController._STATE_CANCELED = 2;
3273 _StreamController._STATE_SUBSCRIPTION_MASK = 3;
3274 _StreamController._STATE_CLOSED = 4;
3275 _StreamController._STATE_ADDSTREAM = 8;
3276 let _SyncStreamControllerDispatch$ = dart.generic(function(T) {
3277 class _SyncStreamControllerDispatch extends core.Object {
3278 [_sendData](data) {
3279 dart.as(data, T);
3280 this[_subscription][_add](data);
3281 }
3282 [_sendError](error, stackTrace) {
3283 this[_subscription][_addError](error, stackTrace);
3284 }
3285 [_sendDone]() {
3286 this[_subscription][_close]();
3287 }
3288 }
3289 _SyncStreamControllerDispatch[dart.implements] = () => [_StreamController$(T )];
3290 dart.setSignature(_SyncStreamControllerDispatch, {
3291 methods: () => ({
3292 [_sendData]: [dart.void, [T]],
3293 [_sendError]: [dart.void, [core.Object, core.StackTrace]],
3294 [_sendDone]: [dart.void, []]
3295 })
3296 });
3297 return _SyncStreamControllerDispatch;
3298 });
3299 let _SyncStreamControllerDispatch = _SyncStreamControllerDispatch$();
3300 let _AsyncStreamControllerDispatch$ = dart.generic(function(T) {
3301 class _AsyncStreamControllerDispatch extends core.Object {
3302 [_sendData](data) {
3303 dart.as(data, T);
3304 this[_subscription][_addPending](new _DelayedData(data));
3305 }
3306 [_sendError](error, stackTrace) {
3307 this[_subscription][_addPending](new _DelayedError(error, stackTrace));
3308 }
3309 [_sendDone]() {
3310 this[_subscription][_addPending](dart.const(new _DelayedDone()));
3311 }
3312 }
3313 _AsyncStreamControllerDispatch[dart.implements] = () => [_StreamController$( T)];
3314 dart.setSignature(_AsyncStreamControllerDispatch, {
3315 methods: () => ({
3316 [_sendData]: [dart.void, [T]],
3317 [_sendError]: [dart.void, [core.Object, core.StackTrace]],
3318 [_sendDone]: [dart.void, []]
3319 })
3320 });
3321 return _AsyncStreamControllerDispatch;
3322 });
3323 let _AsyncStreamControllerDispatch = _AsyncStreamControllerDispatch$();
3324 let _AsyncStreamController$ = dart.generic(function(T) {
3325 class _AsyncStreamController extends dart.mixin(_StreamController$(T), _Asyn cStreamControllerDispatch$(T)) {
3326 _AsyncStreamController(onListen, onPause, onResume, onCancel) {
3327 this[_onListen] = onListen;
3328 this[_onPause] = onPause;
3329 this[_onResume] = onResume;
3330 this[_onCancel] = onCancel;
3331 super._StreamController();
3332 }
3333 }
3334 dart.setSignature(_AsyncStreamController, {
3335 constructors: () => ({_AsyncStreamController: [_AsyncStreamController$(T), [dart.functionType(dart.void, []), dart.functionType(dart.void, []), dart.funct ionType(dart.void, []), dart.functionType(dart.dynamic, [])]]})
3336 });
3337 return _AsyncStreamController;
3338 });
3339 let _AsyncStreamController = _AsyncStreamController$();
3340 let _SyncStreamController$ = dart.generic(function(T) {
3341 class _SyncStreamController extends dart.mixin(_StreamController$(T), _SyncS treamControllerDispatch$(T)) {
3342 _SyncStreamController(onListen, onPause, onResume, onCancel) {
3343 this[_onListen] = onListen;
3344 this[_onPause] = onPause;
3345 this[_onResume] = onResume;
3346 this[_onCancel] = onCancel;
3347 super._StreamController();
3348 }
3349 }
3350 dart.setSignature(_SyncStreamController, {
3351 constructors: () => ({_SyncStreamController: [_SyncStreamController$(T), [ dart.functionType(dart.void, []), dart.functionType(dart.void, []), dart.functio nType(dart.void, []), dart.functionType(dart.dynamic, [])]]})
3352 });
3353 return _SyncStreamController;
3354 });
3355 let _SyncStreamController = _SyncStreamController$();
3356 class _NoCallbacks extends core.Object {
3357 get [_onListen]() {
3358 return null;
3359 }
3360 get [_onPause]() {
3361 return null;
3362 }
3363 get [_onResume]() {
3364 return null;
3365 }
3366 get [_onCancel]() {
3367 return null;
3368 }
3369 }
3370 class _NoCallbackAsyncStreamController extends dart.mixin(_StreamController, _ AsyncStreamControllerDispatch, _NoCallbacks) {
3371 _NoCallbackAsyncStreamController() {
3372 super._StreamController(...arguments);
3373 }
3374 }
3375 class _NoCallbackSyncStreamController extends dart.mixin(_StreamController, _S yncStreamControllerDispatch, _NoCallbacks) {
3376 _NoCallbackSyncStreamController() {
3377 super._StreamController(...arguments);
3378 }
3379 }
3380 let _NotificationHandler = dart.typedef('_NotificationHandler', () => dart.fun ctionType(dart.dynamic, []));
3381 function _runGuarded(notificationHandler) {
3382 if (notificationHandler == null)
3383 return null;
3384 try {
3385 let result = notificationHandler();
3386 if (dart.is(result, Future))
3387 return dart.as(result, Future);
3388 return null;
3389 } catch (e) {
3390 let s = dart.stackTrace(e);
3391 Zone.current.handleUncaughtError(e, s);
3392 }
3393
3394 }
3395 dart.fn(_runGuarded, Future, [_NotificationHandler]);
3396 let _target = Symbol('_target');
3397 let _StreamSinkWrapper$ = dart.generic(function(T) {
3398 class _StreamSinkWrapper extends core.Object {
3399 _StreamSinkWrapper(target) {
3400 this[_target] = target;
3401 }
3402 add(data) {
3403 dart.as(data, T);
3404 this[_target].add(data);
3405 }
3406 addError(error, stackTrace) {
3407 if (stackTrace === void 0)
3408 stackTrace = null;
3409 this[_target].addError(error, stackTrace);
3410 }
3411 close() {
3412 return this[_target].close();
3413 }
3414 addStream(source, opts) {
3415 dart.as(source, Stream$(T));
3416 let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : true;
3417 return this[_target].addStream(source, {cancelOnError: cancelOnError});
3418 }
3419 get done() {
3420 return this[_target].done;
3421 }
3422 }
3423 _StreamSinkWrapper[dart.implements] = () => [StreamSink$(T)];
3424 dart.setSignature(_StreamSinkWrapper, {
3425 constructors: () => ({_StreamSinkWrapper: [_StreamSinkWrapper$(T), [Stream Controller]]}),
3426 methods: () => ({
3427 add: [dart.void, [T]],
3428 addError: [dart.void, [core.Object], [core.StackTrace]],
3429 close: [Future, []],
3430 addStream: [Future, [Stream$(T)], {cancelOnError: core.bool}]
3431 })
3432 });
3433 return _StreamSinkWrapper;
3434 });
3435 let _StreamSinkWrapper = _StreamSinkWrapper$();
3436 let _AddStreamState$ = dart.generic(function(T) {
3437 class _AddStreamState extends core.Object {
3438 _AddStreamState(controller, source, cancelOnError) {
3439 this.addStreamFuture = new _Future();
3440 this.addSubscription = source.listen(dart.bind(controller, _add), {onErr or: dart.notNull(cancelOnError) ? dart.as(_AddStreamState$().makeErrorHandler(co ntroller), core.Function) : dart.bind(controller, _addError), onDone: dart.bind( controller, _close), cancelOnError: cancelOnError});
3441 }
3442 static makeErrorHandler(controller) {
3443 return dart.fn((e, s) => {
3444 controller[_addError](e, s);
3445 controller[_close]();
3446 }, dart.dynamic, [dart.dynamic, core.StackTrace]);
3447 }
3448 pause() {
3449 this.addSubscription.pause();
3450 }
3451 resume() {
3452 this.addSubscription.resume();
3453 }
3454 cancel() {
3455 let cancel = this.addSubscription.cancel();
3456 if (cancel == null) {
3457 this.addStreamFuture[_asyncComplete](null);
3458 return null;
3459 }
3460 return cancel.whenComplete(dart.fn((() => {
3461 this.addStreamFuture[_asyncComplete](null);
3462 }).bind(this)));
3463 }
3464 complete() {
3465 this.addStreamFuture[_asyncComplete](null);
3466 }
3467 }
3468 dart.setSignature(_AddStreamState, {
3469 constructors: () => ({_AddStreamState: [_AddStreamState$(T), [_EventSink$( T), Stream, core.bool]]}),
3470 methods: () => ({
3471 pause: [dart.void, []],
3472 resume: [dart.void, []],
3473 cancel: [Future, []],
3474 complete: [dart.void, []]
3475 }),
3476 statics: () => ({makeErrorHandler: [dart.dynamic, [_EventSink]]}),
3477 names: ['makeErrorHandler']
3478 });
3479 return _AddStreamState;
3480 });
3481 let _AddStreamState = _AddStreamState$();
3482 let _StreamControllerAddStreamState$ = dart.generic(function(T) {
3483 class _StreamControllerAddStreamState extends _AddStreamState$(T) {
3484 _StreamControllerAddStreamState(controller, varData, source, cancelOnError ) {
3485 this.varData = varData;
3486 super._AddStreamState(dart.as(controller, _EventSink$(T)), source, cance lOnError);
3487 if (dart.notNull(controller.isPaused)) {
3488 this.addSubscription.pause();
3489 }
3490 }
3491 }
3492 dart.setSignature(_StreamControllerAddStreamState, {
3493 constructors: () => ({_StreamControllerAddStreamState: [_StreamControllerA ddStreamState$(T), [_StreamController, dart.dynamic, Stream, core.bool]]})
3494 });
3495 return _StreamControllerAddStreamState;
3496 });
3497 let _StreamControllerAddStreamState = _StreamControllerAddStreamState$();
3498 let _EventSink$ = dart.generic(function(T) {
3499 class _EventSink extends core.Object {}
3500 return _EventSink;
3501 });
3502 let _EventSink = _EventSink$();
3503 let _EventDispatch$ = dart.generic(function(T) {
3504 class _EventDispatch extends core.Object {}
3505 return _EventDispatch;
3506 });
3507 let _EventDispatch = _EventDispatch$();
3508 _BufferingStreamSubscription._STATE_CANCEL_ON_ERROR = 1;
3509 _BufferingStreamSubscription._STATE_CLOSED = 2;
3510 _BufferingStreamSubscription._STATE_INPUT_PAUSED = 4;
3511 _BufferingStreamSubscription._STATE_CANCELED = 8;
3512 _BufferingStreamSubscription._STATE_WAIT_FOR_CANCEL = 16;
3513 _BufferingStreamSubscription._STATE_IN_CALLBACK = 32;
3514 _BufferingStreamSubscription._STATE_HAS_PENDING = 64;
3515 _BufferingStreamSubscription._STATE_PAUSE_COUNT = 128;
3516 _BufferingStreamSubscription._STATE_PAUSE_COUNT_SHIFT = 7;
3517 let _EventGenerator = dart.typedef('_EventGenerator', () => dart.functionType( _PendingEvents, []));
3518 let _isUsed = Symbol('_isUsed');
3519 let _GeneratedStreamImpl$ = dart.generic(function(T) {
3520 class _GeneratedStreamImpl extends _StreamImpl$(T) {
3521 _GeneratedStreamImpl(pending) {
3522 this[_pending] = pending;
3523 this[_isUsed] = false;
3524 }
3525 [_createSubscription](onData, onError, onDone, cancelOnError) {
3526 dart.as(onData, dart.functionType(dart.void, [T]));
3527 dart.as(onDone, dart.functionType(dart.void, []));
3528 if (dart.notNull(this[_isUsed]))
3529 dart.throw(new core.StateError("Stream has already been listened to.") );
3530 this[_isUsed] = true;
3531 return dart.as((() => {
3532 let _ = new _BufferingStreamSubscription(onData, onError, onDone, canc elOnError);
3533 _[_setPendingEvents](this[_pending]());
3534 return _;
3535 }).bind(this)(), StreamSubscription$(T));
3536 }
3537 }
3538 dart.setSignature(_GeneratedStreamImpl, {
3539 constructors: () => ({_GeneratedStreamImpl: [_GeneratedStreamImpl$(T), [_E ventGenerator]]}),
3540 methods: () => ({[_createSubscription]: [StreamSubscription$(T), [dart.fun ctionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core .bool]]})
3541 });
3542 return _GeneratedStreamImpl;
3543 });
3544 let _GeneratedStreamImpl = _GeneratedStreamImpl$();
3545 let _eventScheduled = Symbol('_eventScheduled');
3546 class _PendingEvents extends core.Object {
3547 _PendingEvents() {
3548 this[_state] = _PendingEvents._STATE_UNSCHEDULED;
3549 }
3550 get isScheduled() {
3551 return this[_state] == _PendingEvents._STATE_SCHEDULED;
3552 }
3553 get [_eventScheduled]() {
3554 return dart.notNull(this[_state]) >= dart.notNull(_PendingEvents._STATE_SC HEDULED);
3555 }
3556 schedule(dispatch) {
3557 if (dart.notNull(this.isScheduled))
3558 return;
3559 dart.assert(!dart.notNull(this.isEmpty));
3560 if (dart.notNull(this[_eventScheduled])) {
3561 dart.assert(this[_state] == _PendingEvents._STATE_CANCELED);
3562 this[_state] = _PendingEvents._STATE_SCHEDULED;
3563 return;
3564 }
3565 scheduleMicrotask(dart.fn((() => {
3566 let oldState = this[_state];
3567 this[_state] = _PendingEvents._STATE_UNSCHEDULED;
3568 if (oldState == _PendingEvents._STATE_CANCELED)
3569 return;
3570 this.handleNext(dispatch);
3571 }).bind(this)));
3572 this[_state] = _PendingEvents._STATE_SCHEDULED;
3573 }
3574 cancelSchedule() {
3575 if (dart.notNull(this.isScheduled))
3576 this[_state] = _PendingEvents._STATE_CANCELED;
3577 }
3578 }
3579 dart.setSignature(_PendingEvents, {
3580 methods: () => ({
3581 schedule: [dart.void, [_EventDispatch]],
3582 cancelSchedule: [dart.void, []]
3583 })
3584 });
3585 let _iterator = Symbol('_iterator');
3586 let _IterablePendingEvents$ = dart.generic(function(T) {
3587 class _IterablePendingEvents extends _PendingEvents {
3588 _IterablePendingEvents(data) {
3589 this[_iterator] = data[dartx.iterator];
3590 super._PendingEvents();
3591 }
3592 get isEmpty() {
3593 return this[_iterator] == null;
3594 }
3595 handleNext(dispatch) {
3596 if (this[_iterator] == null) {
3597 dart.throw(new core.StateError("No events pending."));
3598 }
3599 let isDone = null;
3600 try {
3601 isDone = !dart.notNull(this[_iterator].moveNext());
3602 } catch (e) {
3603 let s = dart.stackTrace(e);
3604 this[_iterator] = null;
3605 dispatch[_sendError](e, s);
3606 return;
3607 }
3608
3609 if (!dart.notNull(isDone)) {
3610 dispatch[_sendData](this[_iterator].current);
3611 } else {
3612 this[_iterator] = null;
3613 dispatch[_sendDone]();
3614 }
3615 }
3616 clear() {
3617 if (dart.notNull(this.isScheduled))
3618 this.cancelSchedule();
3619 this[_iterator] = null;
3620 }
3621 }
3622 dart.setSignature(_IterablePendingEvents, {
3623 constructors: () => ({_IterablePendingEvents: [_IterablePendingEvents$(T), [core.Iterable$(T)]]}),
3624 methods: () => ({
3625 handleNext: [dart.void, [_EventDispatch]],
3626 clear: [dart.void, []]
3627 })
3628 });
3629 return _IterablePendingEvents;
3630 });
3631 let _IterablePendingEvents = _IterablePendingEvents$();
3632 let _DataHandler$ = dart.generic(function(T) {
3633 let _DataHandler = dart.typedef('_DataHandler', () => dart.functionType(dart .void, [T]));
3634 return _DataHandler;
3635 });
3636 let _DataHandler = _DataHandler$();
3637 let _DoneHandler = dart.typedef('_DoneHandler', () => dart.functionType(dart.v oid, []));
3638 function _nullDataHandler(value) {
3639 }
3640 dart.fn(_nullDataHandler, dart.void, [dart.dynamic]);
3641 function _nullErrorHandler(error, stackTrace) {
3642 if (stackTrace === void 0)
3643 stackTrace = null;
3644 Zone.current.handleUncaughtError(error, stackTrace);
3645 }
3646 dart.fn(_nullErrorHandler, dart.void, [dart.dynamic], [core.StackTrace]);
3647 function _nullDoneHandler() {
3648 }
3649 dart.fn(_nullDoneHandler, dart.void, []);
3650 let _DelayedEvent$ = dart.generic(function(T) {
3651 class _DelayedEvent extends core.Object {
3652 _DelayedEvent() {
3653 this.next = null;
3654 }
3655 }
3656 return _DelayedEvent;
3657 });
3658 let _DelayedEvent = _DelayedEvent$();
3659 let _DelayedData$ = dart.generic(function(T) {
3660 class _DelayedData extends _DelayedEvent$(T) {
3661 _DelayedData(value) {
3662 this.value = value;
3663 super._DelayedEvent();
3664 }
3665 perform(dispatch) {
3666 dart.as(dispatch, _EventDispatch$(T));
3667 dispatch[_sendData](this.value);
3668 }
3669 }
3670 dart.setSignature(_DelayedData, {
3671 constructors: () => ({_DelayedData: [_DelayedData$(T), [T]]}),
3672 methods: () => ({perform: [dart.void, [_EventDispatch$(T)]]})
3673 });
3674 return _DelayedData;
3675 });
3676 let _DelayedData = _DelayedData$();
3677 class _DelayedError extends _DelayedEvent {
3678 _DelayedError(error, stackTrace) {
3679 this.error = error;
3680 this.stackTrace = stackTrace;
3681 super._DelayedEvent();
3682 }
3683 perform(dispatch) {
3684 dispatch[_sendError](this.error, this.stackTrace);
3685 }
3686 }
3687 dart.setSignature(_DelayedError, {
3688 constructors: () => ({_DelayedError: [_DelayedError, [dart.dynamic, core.Sta ckTrace]]}),
3689 methods: () => ({perform: [dart.void, [_EventDispatch]]})
3690 });
3691 class _DelayedDone extends core.Object {
3692 _DelayedDone() {
3693 }
3694 perform(dispatch) {
3695 dispatch[_sendDone]();
3696 }
3697 get next() {
3698 return null;
3699 }
3700 set next(_) {
3701 dart.throw(new core.StateError("No events after a done."));
3702 }
3703 }
3704 _DelayedDone[dart.implements] = () => [_DelayedEvent];
3705 dart.setSignature(_DelayedDone, {
3706 constructors: () => ({_DelayedDone: [_DelayedDone, []]}),
3707 methods: () => ({perform: [dart.void, [_EventDispatch]]})
3708 });
3709 _PendingEvents._STATE_UNSCHEDULED = 0;
3710 _PendingEvents._STATE_SCHEDULED = 1;
3711 _PendingEvents._STATE_CANCELED = 3;
3712 class _StreamImplEvents extends _PendingEvents {
3713 _StreamImplEvents() {
3714 this.firstPendingEvent = null;
3715 this.lastPendingEvent = null;
3716 super._PendingEvents();
3717 }
3718 get isEmpty() {
3719 return this.lastPendingEvent == null;
3720 }
3721 add(event) {
3722 if (this.lastPendingEvent == null) {
3723 this.firstPendingEvent = this.lastPendingEvent = event;
3724 } else {
3725 this.lastPendingEvent = this.lastPendingEvent.next = event;
3726 }
3727 }
3728 handleNext(dispatch) {
3729 dart.assert(!dart.notNull(this.isScheduled));
3730 let event = this.firstPendingEvent;
3731 this.firstPendingEvent = event.next;
3732 if (this.firstPendingEvent == null) {
3733 this.lastPendingEvent = null;
3734 }
3735 event.perform(dispatch);
3736 }
3737 clear() {
3738 if (dart.notNull(this.isScheduled))
3739 this.cancelSchedule();
3740 this.firstPendingEvent = this.lastPendingEvent = null;
3741 }
3742 }
3743 dart.setSignature(_StreamImplEvents, {
3744 methods: () => ({
3745 add: [dart.void, [_DelayedEvent]],
3746 handleNext: [dart.void, [_EventDispatch]],
3747 clear: [dart.void, []]
3748 })
3749 });
3750 let _unlink = Symbol('_unlink');
3751 let _insertBefore = Symbol('_insertBefore');
3752 class _BroadcastLinkedList extends core.Object {
3753 _BroadcastLinkedList() {
3754 this[_next] = null;
3755 this[_previous] = null;
3756 }
3757 [_unlink]() {
3758 this[_previous][_next] = this[_next];
3759 this[_next][_previous] = this[_previous];
3760 this[_next] = this[_previous] = this;
3761 }
3762 [_insertBefore](newNext) {
3763 let newPrevious = newNext[_previous];
3764 newPrevious[_next] = this;
3765 newNext[_previous] = this[_previous];
3766 this[_previous][_next] = newNext;
3767 this[_previous] = newPrevious;
3768 }
3769 }
3770 dart.setSignature(_BroadcastLinkedList, {
3771 methods: () => ({
3772 [_unlink]: [dart.void, []],
3773 [_insertBefore]: [dart.void, [_BroadcastLinkedList]]
3774 })
3775 });
3776 let _broadcastCallback = dart.typedef('_broadcastCallback', () => dart.functio nType(dart.void, [StreamSubscription]));
3777 let _schedule = Symbol('_schedule');
3778 let _isSent = Symbol('_isSent');
3779 let _isScheduled = Symbol('_isScheduled');
3780 let _DoneStreamSubscription$ = dart.generic(function(T) {
3781 class _DoneStreamSubscription extends core.Object {
3782 _DoneStreamSubscription(onDone) {
3783 this[_onDone] = onDone;
3784 this[_zone] = Zone.current;
3785 this[_state] = 0;
3786 this[_schedule]();
3787 }
3788 get [_isSent]() {
3789 return (dart.notNull(this[_state]) & dart.notNull(_DoneStreamSubscriptio n$()._DONE_SENT)) != 0;
3790 }
3791 get [_isScheduled]() {
3792 return (dart.notNull(this[_state]) & dart.notNull(_DoneStreamSubscriptio n$()._SCHEDULED)) != 0;
3793 }
3794 get isPaused() {
3795 return dart.notNull(this[_state]) >= dart.notNull(_DoneStreamSubscriptio n$()._PAUSED);
3796 }
3797 [_schedule]() {
3798 if (dart.notNull(this[_isScheduled]))
3799 return;
3800 this[_zone].scheduleMicrotask(dart.bind(this, _sendDone));
3801 this[_state] = dart.notNull(this[_state]) | dart.notNull(_DoneStreamSubs cription$()._SCHEDULED);
3802 }
3803 onData(handleData) {
3804 dart.as(handleData, dart.functionType(dart.void, [T]));
3805 }
3806 onError(handleError) {}
3807 onDone(handleDone) {
3808 dart.as(handleDone, dart.functionType(dart.void, []));
3809 this[_onDone] = handleDone;
3810 }
3811 pause(resumeSignal) {
3812 if (resumeSignal === void 0)
3813 resumeSignal = null;
3814 this[_state] = dart.notNull(this[_state]) + dart.notNull(_DoneStreamSubs cription$()._PAUSED);
3815 if (resumeSignal != null)
3816 resumeSignal.whenComplete(dart.bind(this, 'resume'));
3817 }
3818 resume() {
3819 if (dart.notNull(this.isPaused)) {
3820 this[_state] = dart.notNull(this[_state]) - dart.notNull(_DoneStreamSu bscription$()._PAUSED);
3821 if (!dart.notNull(this.isPaused) && !dart.notNull(this[_isSent])) {
3822 this[_schedule]();
3823 }
3824 }
3825 }
3826 cancel() {
3827 return null;
3828 }
3829 asFuture(futureValue) {
3830 if (futureValue === void 0)
3831 futureValue = null;
3832 let result = new _Future();
3833 this[_onDone] = dart.fn(() => {
3834 result[_completeWithValue](null);
3835 });
3836 return result;
3837 }
3838 [_sendDone]() {
3839 this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_DoneStreamSub scription$()._SCHEDULED);
3840 if (dart.notNull(this.isPaused))
3841 return;
3842 this[_state] = dart.notNull(this[_state]) | dart.notNull(_DoneStreamSubs cription$()._DONE_SENT);
3843 if (this[_onDone] != null)
3844 this[_zone].runGuarded(this[_onDone]);
3845 }
3846 }
3847 _DoneStreamSubscription[dart.implements] = () => [StreamSubscription$(T)];
3848 dart.setSignature(_DoneStreamSubscription, {
3849 constructors: () => ({_DoneStreamSubscription: [_DoneStreamSubscription$(T ), [_DoneHandler]]}),
3850 methods: () => ({
3851 [_schedule]: [dart.void, []],
3852 onData: [dart.void, [dart.functionType(dart.void, [T])]],
3853 onError: [dart.void, [core.Function]],
3854 onDone: [dart.void, [dart.functionType(dart.void, [])]],
3855 pause: [dart.void, [], [Future]],
3856 resume: [dart.void, []],
3857 cancel: [Future, []],
3858 asFuture: [Future, [], [dart.dynamic]],
3859 [_sendDone]: [dart.void, []]
3860 })
3861 });
3862 return _DoneStreamSubscription;
3863 });
3864 let _DoneStreamSubscription = _DoneStreamSubscription$();
3865 _DoneStreamSubscription._DONE_SENT = 1;
3866 _DoneStreamSubscription._SCHEDULED = 2;
3867 _DoneStreamSubscription._PAUSED = 4;
3868 let _source = Symbol('_source');
3869 let _onListenHandler = Symbol('_onListenHandler');
3870 let _onCancelHandler = Symbol('_onCancelHandler');
3871 let _cancelSubscription = Symbol('_cancelSubscription');
3872 let _pauseSubscription = Symbol('_pauseSubscription');
3873 let _resumeSubscription = Symbol('_resumeSubscription');
3874 let _isSubscriptionPaused = Symbol('_isSubscriptionPaused');
3875 let _AsBroadcastStream$ = dart.generic(function(T) {
3876 class _AsBroadcastStream extends Stream$(T) {
3877 _AsBroadcastStream(source, onListenHandler, onCancelHandler) {
3878 this[_source] = source;
3879 this[_onListenHandler] = dart.as(Zone.current.registerUnaryCallback(onLi stenHandler), _broadcastCallback);
3880 this[_onCancelHandler] = dart.as(Zone.current.registerUnaryCallback(onCa ncelHandler), _broadcastCallback);
3881 this[_zone] = Zone.current;
3882 this[_controller] = null;
3883 this[_subscription] = null;
3884 super.Stream();
3885 this[_controller] = new (_AsBroadcastStreamController$(T))(dart.bind(thi s, _onListen), dart.bind(this, _onCancel));
3886 }
3887 get isBroadcast() {
3888 return true;
3889 }
3890 listen(onData, opts) {
3891 dart.as(onData, dart.functionType(dart.void, [T]));
3892 let onError = opts && 'onError' in opts ? opts.onError : null;
3893 let onDone = opts && 'onDone' in opts ? opts.onDone : null;
3894 dart.as(onDone, dart.functionType(dart.void, []));
3895 let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
3896 if (this[_controller] == null || dart.notNull(this[_controller].isClosed )) {
3897 return new (_DoneStreamSubscription$(T))(onDone);
3898 }
3899 if (this[_subscription] == null) {
3900 this[_subscription] = this[_source].listen(dart.bind(this[_controller] , 'add'), {onError: dart.bind(this[_controller], 'addError'), onDone: dart.bind( this[_controller], 'close')});
3901 }
3902 cancelOnError = core.identical(true, cancelOnError);
3903 return this[_controller][_subscribe](onData, onError, onDone, cancelOnEr ror);
3904 }
3905 [_onCancel]() {
3906 let shutdown = this[_controller] == null || dart.notNull(this[_controlle r].isClosed);
3907 if (this[_onCancelHandler] != null) {
3908 this[_zone].runUnary(this[_onCancelHandler], new _BroadcastSubscriptio nWrapper(this));
3909 }
3910 if (dart.notNull(shutdown)) {
3911 if (this[_subscription] != null) {
3912 this[_subscription].cancel();
3913 this[_subscription] = null;
3914 }
3915 }
3916 }
3917 [_onListen]() {
3918 if (this[_onListenHandler] != null) {
3919 this[_zone].runUnary(this[_onListenHandler], new _BroadcastSubscriptio nWrapper(this));
3920 }
3921 }
3922 [_cancelSubscription]() {
3923 if (this[_subscription] == null)
3924 return;
3925 let subscription = this[_subscription];
3926 this[_subscription] = null;
3927 this[_controller] = null;
3928 subscription.cancel();
3929 }
3930 [_pauseSubscription](resumeSignal) {
3931 if (this[_subscription] == null)
3932 return;
3933 this[_subscription].pause(resumeSignal);
3934 }
3935 [_resumeSubscription]() {
3936 if (this[_subscription] == null)
3937 return;
3938 this[_subscription].resume();
3939 }
3940 get [_isSubscriptionPaused]() {
3941 if (this[_subscription] == null)
3942 return false;
3943 return this[_subscription].isPaused;
3944 }
3945 }
3946 dart.setSignature(_AsBroadcastStream, {
3947 constructors: () => ({_AsBroadcastStream: [_AsBroadcastStream$(T), [Stream $(T), dart.functionType(dart.void, [StreamSubscription]), dart.functionType(dart .void, [StreamSubscription])]]}),
3948 methods: () => ({
3949 listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {o nError: core.Function, onDone: dart.functionType(dart.void, []), cancelOnError: core.bool}],
3950 [_onCancel]: [dart.void, []],
3951 [_onListen]: [dart.void, []],
3952 [_cancelSubscription]: [dart.void, []],
3953 [_pauseSubscription]: [dart.void, [Future]],
3954 [_resumeSubscription]: [dart.void, []]
3955 })
3956 });
3957 return _AsBroadcastStream;
3958 });
3959 let _AsBroadcastStream = _AsBroadcastStream$();
3960 let _BroadcastSubscriptionWrapper$ = dart.generic(function(T) {
3961 class _BroadcastSubscriptionWrapper extends core.Object {
3962 _BroadcastSubscriptionWrapper(stream) {
3963 this[_stream] = stream;
3964 }
3965 onData(handleData) {
3966 dart.as(handleData, dart.functionType(dart.void, [T]));
3967 dart.throw(new core.UnsupportedError("Cannot change handlers of asBroadc astStream source subscription."));
3968 }
3969 onError(handleError) {
3970 dart.throw(new core.UnsupportedError("Cannot change handlers of asBroadc astStream source subscription."));
3971 }
3972 onDone(handleDone) {
3973 dart.as(handleDone, dart.functionType(dart.void, []));
3974 dart.throw(new core.UnsupportedError("Cannot change handlers of asBroadc astStream source subscription."));
3975 }
3976 pause(resumeSignal) {
3977 if (resumeSignal === void 0)
3978 resumeSignal = null;
3979 this[_stream][_pauseSubscription](resumeSignal);
3980 }
3981 resume() {
3982 this[_stream][_resumeSubscription]();
3983 }
3984 cancel() {
3985 this[_stream][_cancelSubscription]();
3986 return null;
3987 }
3988 get isPaused() {
3989 return this[_stream][_isSubscriptionPaused];
3990 }
3991 asFuture(futureValue) {
3992 if (futureValue === void 0)
3993 futureValue = null;
3994 dart.throw(new core.UnsupportedError("Cannot change handlers of asBroadc astStream source subscription."));
3995 }
3996 }
3997 _BroadcastSubscriptionWrapper[dart.implements] = () => [StreamSubscription$( T)];
3998 dart.setSignature(_BroadcastSubscriptionWrapper, {
3999 constructors: () => ({_BroadcastSubscriptionWrapper: [_BroadcastSubscripti onWrapper$(T), [_AsBroadcastStream]]}),
4000 methods: () => ({
4001 onData: [dart.void, [dart.functionType(dart.void, [T])]],
4002 onError: [dart.void, [core.Function]],
4003 onDone: [dart.void, [dart.functionType(dart.void, [])]],
4004 pause: [dart.void, [], [Future]],
4005 resume: [dart.void, []],
4006 cancel: [Future, []],
4007 asFuture: [Future, [], [dart.dynamic]]
4008 })
4009 });
4010 return _BroadcastSubscriptionWrapper;
4011 });
4012 let _BroadcastSubscriptionWrapper = _BroadcastSubscriptionWrapper$();
4013 let _current = Symbol('_current');
4014 let _futureOrPrefetch = Symbol('_futureOrPrefetch');
4015 let _clear = Symbol('_clear');
4016 let _StreamIteratorImpl$ = dart.generic(function(T) {
4017 class _StreamIteratorImpl extends core.Object {
4018 _StreamIteratorImpl(stream) {
4019 this[_subscription] = null;
4020 this[_current] = null;
4021 this[_futureOrPrefetch] = null;
4022 this[_state] = _StreamIteratorImpl$()._STATE_FOUND;
4023 this[_subscription] = stream.listen(dart.bind(this, _onData), {onError: dart.bind(this, _onError), onDone: dart.bind(this, _onDone), cancelOnError: true });
4024 }
4025 get current() {
4026 return this[_current];
4027 }
4028 moveNext() {
4029 if (this[_state] == _StreamIteratorImpl$()._STATE_DONE) {
4030 return new (_Future$(core.bool)).immediate(false);
4031 }
4032 if (this[_state] == _StreamIteratorImpl$()._STATE_MOVING) {
4033 dart.throw(new core.StateError("Already waiting for next."));
4034 }
4035 if (this[_state] == _StreamIteratorImpl$()._STATE_FOUND) {
4036 this[_state] = _StreamIteratorImpl$()._STATE_MOVING;
4037 this[_current] = null;
4038 this[_futureOrPrefetch] = new (_Future$(core.bool))();
4039 return dart.as(this[_futureOrPrefetch], Future$(core.bool));
4040 } else {
4041 dart.assert(dart.notNull(this[_state]) >= dart.notNull(_StreamIterator Impl$()._STATE_EXTRA_DATA));
4042 switch (this[_state]) {
4043 case _StreamIteratorImpl$()._STATE_EXTRA_DATA:
4044 {
4045 this[_state] = _StreamIteratorImpl$()._STATE_FOUND;
4046 this[_current] = dart.as(this[_futureOrPrefetch], T);
4047 this[_futureOrPrefetch] = null;
4048 this[_subscription].resume();
4049 return new (_Future$(core.bool)).immediate(true);
4050 }
4051 case _StreamIteratorImpl$()._STATE_EXTRA_ERROR:
4052 {
4053 let prefetch = dart.as(this[_futureOrPrefetch], AsyncError);
4054 this[_clear]();
4055 return new (_Future$(core.bool)).immediateError(prefetch.error, pr efetch.stackTrace);
4056 }
4057 case _StreamIteratorImpl$()._STATE_EXTRA_DONE:
4058 {
4059 this[_clear]();
4060 return new (_Future$(core.bool)).immediate(false);
4061 }
4062 }
4063 }
4064 }
4065 [_clear]() {
4066 this[_subscription] = null;
4067 this[_futureOrPrefetch] = null;
4068 this[_current] = null;
4069 this[_state] = _StreamIteratorImpl$()._STATE_DONE;
4070 }
4071 cancel() {
4072 let subscription = this[_subscription];
4073 if (subscription == null)
4074 return null;
4075 if (this[_state] == _StreamIteratorImpl$()._STATE_MOVING) {
4076 let hasNext = dart.as(this[_futureOrPrefetch], _Future$(core.bool));
4077 this[_clear]();
4078 hasNext[_complete](false);
4079 } else {
4080 this[_clear]();
4081 }
4082 return subscription.cancel();
4083 }
4084 [_onData](data) {
4085 dart.as(data, T);
4086 if (this[_state] == _StreamIteratorImpl$()._STATE_MOVING) {
4087 this[_current] = data;
4088 let hasNext = dart.as(this[_futureOrPrefetch], _Future$(core.bool));
4089 this[_futureOrPrefetch] = null;
4090 this[_state] = _StreamIteratorImpl$()._STATE_FOUND;
4091 hasNext[_complete](true);
4092 return;
4093 }
4094 this[_subscription].pause();
4095 dart.assert(this[_futureOrPrefetch] == null);
4096 this[_futureOrPrefetch] = data;
4097 this[_state] = _StreamIteratorImpl$()._STATE_EXTRA_DATA;
4098 }
4099 [_onError](error, stackTrace) {
4100 if (stackTrace === void 0)
4101 stackTrace = null;
4102 if (this[_state] == _StreamIteratorImpl$()._STATE_MOVING) {
4103 let hasNext = dart.as(this[_futureOrPrefetch], _Future$(core.bool));
4104 this[_clear]();
4105 hasNext[_completeError](error, stackTrace);
4106 return;
4107 }
4108 this[_subscription].pause();
4109 dart.assert(this[_futureOrPrefetch] == null);
4110 this[_futureOrPrefetch] = new AsyncError(error, stackTrace);
4111 this[_state] = _StreamIteratorImpl$()._STATE_EXTRA_ERROR;
4112 }
4113 [_onDone]() {
4114 if (this[_state] == _StreamIteratorImpl$()._STATE_MOVING) {
4115 let hasNext = dart.as(this[_futureOrPrefetch], _Future$(core.bool));
4116 this[_clear]();
4117 hasNext[_complete](false);
4118 return;
4119 }
4120 this[_subscription].pause();
4121 this[_futureOrPrefetch] = null;
4122 this[_state] = _StreamIteratorImpl$()._STATE_EXTRA_DONE;
4123 }
4124 }
4125 _StreamIteratorImpl[dart.implements] = () => [StreamIterator$(T)];
4126 dart.setSignature(_StreamIteratorImpl, {
4127 constructors: () => ({_StreamIteratorImpl: [_StreamIteratorImpl$(T), [Stre am$(T)]]}),
4128 methods: () => ({
4129 moveNext: [Future$(core.bool), []],
4130 [_clear]: [dart.void, []],
4131 cancel: [Future, []],
4132 [_onData]: [dart.void, [T]],
4133 [_onError]: [dart.void, [core.Object], [core.StackTrace]],
4134 [_onDone]: [dart.void, []]
4135 })
4136 });
4137 return _StreamIteratorImpl;
4138 });
4139 let _StreamIteratorImpl = _StreamIteratorImpl$();
4140 _StreamIteratorImpl._STATE_FOUND = 0;
4141 _StreamIteratorImpl._STATE_DONE = 1;
4142 _StreamIteratorImpl._STATE_MOVING = 2;
4143 _StreamIteratorImpl._STATE_EXTRA_DATA = 3;
4144 _StreamIteratorImpl._STATE_EXTRA_ERROR = 4;
4145 _StreamIteratorImpl._STATE_EXTRA_DONE = 5;
4146 let __CastType20$ = dart.generic(function(T) {
4147 let __CastType20 = dart.typedef('__CastType20', () => dart.functionType(dart .void, [T]));
4148 return __CastType20;
4149 });
4150 let __CastType20 = __CastType20$();
4151 let __CastType22 = dart.typedef('__CastType22', () => dart.functionType(dart.d ynamic, [dart.dynamic, dart.dynamic]));
4152 let __CastType25 = dart.typedef('__CastType25', () => dart.functionType(dart.d ynamic, [dart.dynamic]));
4153 function _runUserCode(userCode, onSuccess, onError) {
4154 try {
4155 dart.dcall(onSuccess, userCode());
4156 } catch (e) {
4157 let s = dart.stackTrace(e);
4158 let replacement = Zone.current.errorCallback(e, s);
4159 if (replacement == null) {
4160 dart.dcall(onError, e, s);
4161 } else {
4162 let error = _nonNullError(replacement.error);
4163 let stackTrace = replacement.stackTrace;
4164 dart.dcall(onError, error, stackTrace);
4165 }
4166 }
4167
4168 }
4169 dart.fn(_runUserCode, dart.dynamic, [dart.functionType(dart.dynamic, []), dart .functionType(dart.dynamic, [dart.dynamic]), dart.functionType(dart.dynamic, [da rt.dynamic, core.StackTrace])]);
4170 function _cancelAndError(subscription, future, error, stackTrace) {
4171 let cancelFuture = subscription.cancel();
4172 if (dart.is(cancelFuture, Future)) {
4173 cancelFuture.whenComplete(dart.fn(() => future[_completeError](error, stac kTrace), dart.void, []));
4174 } else {
4175 future[_completeError](error, stackTrace);
4176 }
4177 }
4178 dart.fn(_cancelAndError, dart.void, [StreamSubscription, _Future, dart.dynamic , core.StackTrace]);
4179 function _cancelAndErrorWithReplacement(subscription, future, error, stackTrac e) {
4180 let replacement = Zone.current.errorCallback(error, stackTrace);
4181 if (replacement != null) {
4182 error = _nonNullError(replacement.error);
4183 stackTrace = replacement.stackTrace;
4184 }
4185 _cancelAndError(subscription, future, error, stackTrace);
4186 }
4187 dart.fn(_cancelAndErrorWithReplacement, dart.void, [StreamSubscription, _Futur e, dart.dynamic, core.StackTrace]);
4188 function _cancelAndErrorClosure(subscription, future) {
4189 return dart.fn((error, stackTrace) => _cancelAndError(subscription, future, error, stackTrace), dart.void, [dart.dynamic, core.StackTrace]);
4190 }
4191 dart.fn(_cancelAndErrorClosure, dart.dynamic, [StreamSubscription, _Future]);
4192 function _cancelAndValue(subscription, future, value) {
4193 let cancelFuture = subscription.cancel();
4194 if (dart.is(cancelFuture, Future)) {
4195 cancelFuture.whenComplete(dart.fn(() => future[_complete](value), dart.voi d, []));
4196 } else {
4197 future[_complete](value);
4198 }
4199 }
4200 dart.fn(_cancelAndValue, dart.void, [StreamSubscription, _Future, dart.dynamic ]);
4201 let _handleData = Symbol('_handleData');
4202 let _handleError = Symbol('_handleError');
4203 let _handleDone = Symbol('_handleDone');
4204 let _ForwardingStream$ = dart.generic(function(S, T) {
4205 class _ForwardingStream extends Stream$(T) {
4206 _ForwardingStream(source) {
4207 this[_source] = source;
4208 super.Stream();
4209 }
4210 get isBroadcast() {
4211 return this[_source].isBroadcast;
4212 }
4213 listen(onData, opts) {
4214 dart.as(onData, dart.functionType(dart.void, [T]));
4215 let onError = opts && 'onError' in opts ? opts.onError : null;
4216 let onDone = opts && 'onDone' in opts ? opts.onDone : null;
4217 dart.as(onDone, dart.functionType(dart.void, []));
4218 let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
4219 cancelOnError = core.identical(true, cancelOnError);
4220 return this[_createSubscription](onData, onError, onDone, cancelOnError) ;
4221 }
4222 [_createSubscription](onData, onError, onDone, cancelOnError) {
4223 dart.as(onData, dart.functionType(dart.void, [T]));
4224 dart.as(onDone, dart.functionType(dart.void, []));
4225 return new (_ForwardingStreamSubscription$(S, T))(this, onData, onError, onDone, cancelOnError);
4226 }
4227 [_handleData](data, sink) {
4228 dart.as(data, S);
4229 dart.as(sink, _EventSink$(T));
4230 let outputData = data;
4231 sink[_add](dart.as(outputData, T));
4232 }
4233 [_handleError](error, stackTrace, sink) {
4234 dart.as(sink, _EventSink$(T));
4235 sink[_addError](error, stackTrace);
4236 }
4237 [_handleDone](sink) {
4238 dart.as(sink, _EventSink$(T));
4239 sink[_close]();
4240 }
4241 }
4242 dart.setSignature(_ForwardingStream, {
4243 constructors: () => ({_ForwardingStream: [_ForwardingStream$(S, T), [Strea m$(S)]]}),
4244 methods: () => ({
4245 listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {o nError: core.Function, onDone: dart.functionType(dart.void, []), cancelOnError: core.bool}],
4246 [_createSubscription]: [StreamSubscription$(T), [dart.functionType(dart. void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]],
4247 [_handleData]: [dart.void, [S, _EventSink$(T)]],
4248 [_handleError]: [dart.void, [dart.dynamic, core.StackTrace, _EventSink$( T)]],
4249 [_handleDone]: [dart.void, [_EventSink$(T)]]
4250 })
4251 });
4252 return _ForwardingStream;
4253 });
4254 let _ForwardingStream = _ForwardingStream$();
4255 let _ForwardingStreamSubscription$ = dart.generic(function(S, T) {
4256 class _ForwardingStreamSubscription extends _BufferingStreamSubscription$(T) {
4257 _ForwardingStreamSubscription(stream, onData, onError, onDone, cancelOnErr or) {
4258 this[_stream] = stream;
4259 this[_subscription] = null;
4260 super._BufferingStreamSubscription(onData, onError, onDone, cancelOnErro r);
4261 this[_subscription] = this[_stream][_source].listen(dart.bind(this, _han dleData), {onError: dart.bind(this, _handleError), onDone: dart.bind(this, _hand leDone)});
4262 }
4263 [_add](data) {
4264 dart.as(data, T);
4265 if (dart.notNull(this[_isClosed]))
4266 return;
4267 super[_add](data);
4268 }
4269 [_addError](error, stackTrace) {
4270 if (dart.notNull(this[_isClosed]))
4271 return;
4272 super[_addError](error, stackTrace);
4273 }
4274 [_onPause]() {
4275 if (this[_subscription] == null)
4276 return;
4277 this[_subscription].pause();
4278 }
4279 [_onResume]() {
4280 if (this[_subscription] == null)
4281 return;
4282 this[_subscription].resume();
4283 }
4284 [_onCancel]() {
4285 if (this[_subscription] != null) {
4286 let subscription = this[_subscription];
4287 this[_subscription] = null;
4288 subscription.cancel();
4289 }
4290 return null;
4291 }
4292 [_handleData](data) {
4293 dart.as(data, S);
4294 this[_stream][_handleData](data, this);
4295 }
4296 [_handleError](error, stackTrace) {
4297 this[_stream][_handleError](error, stackTrace, this);
4298 }
4299 [_handleDone]() {
4300 this[_stream][_handleDone](this);
4301 }
4302 }
4303 dart.setSignature(_ForwardingStreamSubscription, {
4304 constructors: () => ({_ForwardingStreamSubscription: [_ForwardingStreamSub scription$(S, T), [_ForwardingStream$(S, T), dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]]}),
4305 methods: () => ({
4306 [_add]: [dart.void, [T]],
4307 [_handleData]: [dart.void, [S]],
4308 [_handleError]: [dart.void, [dart.dynamic, core.StackTrace]],
4309 [_handleDone]: [dart.void, []]
4310 })
4311 });
4312 return _ForwardingStreamSubscription;
4313 });
4314 let _ForwardingStreamSubscription = _ForwardingStreamSubscription$();
4315 let _Predicate$ = dart.generic(function(T) {
4316 let _Predicate = dart.typedef('_Predicate', () => dart.functionType(core.boo l, [T]));
4317 return _Predicate;
4318 });
4319 let _Predicate = _Predicate$();
4320 function _addErrorWithReplacement(sink, error, stackTrace) {
4321 let replacement = Zone.current.errorCallback(error, dart.as(stackTrace, core .StackTrace));
4322 if (replacement != null) {
4323 error = _nonNullError(replacement.error);
4324 stackTrace = replacement.stackTrace;
4325 }
4326 sink[_addError](error, dart.as(stackTrace, core.StackTrace));
4327 }
4328 dart.fn(_addErrorWithReplacement, dart.void, [_EventSink, dart.dynamic, dart.d ynamic]);
4329 let _test = Symbol('_test');
4330 let _WhereStream$ = dart.generic(function(T) {
4331 class _WhereStream extends _ForwardingStream$(T, T) {
4332 _WhereStream(source, test) {
4333 this[_test] = test;
4334 super._ForwardingStream(source);
4335 }
4336 [_handleData](inputEvent, sink) {
4337 dart.as(inputEvent, T);
4338 dart.as(sink, _EventSink$(T));
4339 let satisfies = null;
4340 try {
4341 satisfies = this[_test](inputEvent);
4342 } catch (e) {
4343 let s = dart.stackTrace(e);
4344 _addErrorWithReplacement(sink, e, s);
4345 return;
4346 }
4347
4348 if (dart.notNull(satisfies)) {
4349 sink[_add](inputEvent);
4350 }
4351 }
4352 }
4353 dart.setSignature(_WhereStream, {
4354 constructors: () => ({_WhereStream: [_WhereStream$(T), [Stream$(T), dart.f unctionType(core.bool, [T])]]}),
4355 methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
4356 });
4357 return _WhereStream;
4358 });
4359 let _WhereStream = _WhereStream$();
4360 let _Transformation$ = dart.generic(function(S, T) {
4361 let _Transformation = dart.typedef('_Transformation', () => dart.functionTyp e(T, [S]));
4362 return _Transformation;
4363 });
4364 let _Transformation = _Transformation$();
4365 let _transform = Symbol('_transform');
4366 let _MapStream$ = dart.generic(function(S, T) {
4367 class _MapStream extends _ForwardingStream$(S, T) {
4368 _MapStream(source, transform) {
4369 this[_transform] = transform;
4370 super._ForwardingStream(source);
4371 }
4372 [_handleData](inputEvent, sink) {
4373 dart.as(inputEvent, S);
4374 dart.as(sink, _EventSink$(T));
4375 let outputEvent = null;
4376 try {
4377 outputEvent = dart.as(dart.dcall(this[_transform], inputEvent), T);
4378 } catch (e) {
4379 let s = dart.stackTrace(e);
4380 _addErrorWithReplacement(sink, e, s);
4381 return;
4382 }
4383
4384 sink[_add](outputEvent);
4385 }
4386 }
4387 dart.setSignature(_MapStream, {
4388 constructors: () => ({_MapStream: [_MapStream$(S, T), [Stream$(S), dart.fu nctionType(T, [S])]]}),
4389 methods: () => ({[_handleData]: [dart.void, [S, _EventSink$(T)]]})
4390 });
4391 return _MapStream;
4392 });
4393 let _MapStream = _MapStream$();
4394 let _expand = Symbol('_expand');
4395 let _ExpandStream$ = dart.generic(function(S, T) {
4396 class _ExpandStream extends _ForwardingStream$(S, T) {
4397 _ExpandStream(source, expand) {
4398 this[_expand] = expand;
4399 super._ForwardingStream(source);
4400 }
4401 [_handleData](inputEvent, sink) {
4402 dart.as(inputEvent, S);
4403 dart.as(sink, _EventSink$(T));
4404 try {
4405 for (let value of this[_expand](inputEvent)) {
4406 sink[_add](value);
4407 }
4408 } catch (e) {
4409 let s = dart.stackTrace(e);
4410 _addErrorWithReplacement(sink, e, s);
4411 }
4412
4413 }
4414 }
4415 dart.setSignature(_ExpandStream, {
4416 constructors: () => ({_ExpandStream: [_ExpandStream$(S, T), [Stream$(S), d art.functionType(core.Iterable$(T), [S])]]}),
4417 methods: () => ({[_handleData]: [dart.void, [S, _EventSink$(T)]]})
4418 });
4419 return _ExpandStream;
4420 });
4421 let _ExpandStream = _ExpandStream$();
4422 let _ErrorTest = dart.typedef('_ErrorTest', () => dart.functionType(core.bool, [dart.dynamic]));
4423 let _HandleErrorStream$ = dart.generic(function(T) {
4424 class _HandleErrorStream extends _ForwardingStream$(T, T) {
4425 _HandleErrorStream(source, onError, test) {
4426 this[_transform] = onError;
4427 this[_test] = test;
4428 super._ForwardingStream(source);
4429 }
4430 [_handleError](error, stackTrace, sink) {
4431 dart.as(sink, _EventSink$(T));
4432 let matches = true;
4433 if (this[_test] != null) {
4434 try {
4435 matches = dart.dcall(this[_test], error);
4436 } catch (e) {
4437 let s = dart.stackTrace(e);
4438 _addErrorWithReplacement(sink, e, s);
4439 return;
4440 }
4441
4442 }
4443 if (dart.notNull(matches)) {
4444 try {
4445 _invokeErrorHandler(this[_transform], error, stackTrace);
4446 } catch (e) {
4447 let s = dart.stackTrace(e);
4448 if (dart.notNull(core.identical(e, error))) {
4449 sink[_addError](error, stackTrace);
4450 } else {
4451 _addErrorWithReplacement(sink, e, s);
4452 }
4453 return;
4454 }
4455
4456 } else {
4457 sink[_addError](error, stackTrace);
4458 }
4459 }
4460 }
4461 dart.setSignature(_HandleErrorStream, {
4462 constructors: () => ({_HandleErrorStream: [_HandleErrorStream$(T), [Stream $(T), core.Function, dart.functionType(core.bool, [dart.dynamic])]]}),
4463 methods: () => ({[_handleError]: [dart.void, [core.Object, core.StackTrace , _EventSink$(T)]]})
4464 });
4465 return _HandleErrorStream;
4466 });
4467 let _HandleErrorStream = _HandleErrorStream$();
4468 let _remaining = Symbol('_remaining');
4469 let _TakeStream$ = dart.generic(function(T) {
4470 class _TakeStream extends _ForwardingStream$(T, T) {
4471 _TakeStream(source, count) {
4472 this[_remaining] = count;
4473 super._ForwardingStream(source);
4474 if (!(typeof count == 'number'))
4475 dart.throw(new core.ArgumentError(count));
4476 }
4477 [_handleData](inputEvent, sink) {
4478 dart.as(inputEvent, T);
4479 dart.as(sink, _EventSink$(T));
4480 if (dart.notNull(this[_remaining]) > 0) {
4481 sink[_add](inputEvent);
4482 this[_remaining] = dart.notNull(this[_remaining]) - 1;
4483 if (this[_remaining] == 0) {
4484 sink[_close]();
4485 }
4486 }
4487 }
4488 }
4489 dart.setSignature(_TakeStream, {
4490 constructors: () => ({_TakeStream: [_TakeStream$(T), [Stream$(T), core.int ]]}),
4491 methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
4492 });
4493 return _TakeStream;
4494 });
4495 let _TakeStream = _TakeStream$();
4496 let _TakeWhileStream$ = dart.generic(function(T) {
4497 class _TakeWhileStream extends _ForwardingStream$(T, T) {
4498 _TakeWhileStream(source, test) {
4499 this[_test] = test;
4500 super._ForwardingStream(source);
4501 }
4502 [_handleData](inputEvent, sink) {
4503 dart.as(inputEvent, T);
4504 dart.as(sink, _EventSink$(T));
4505 let satisfies = null;
4506 try {
4507 satisfies = this[_test](inputEvent);
4508 } catch (e) {
4509 let s = dart.stackTrace(e);
4510 _addErrorWithReplacement(sink, e, s);
4511 sink[_close]();
4512 return;
4513 }
4514
4515 if (dart.notNull(satisfies)) {
4516 sink[_add](inputEvent);
4517 } else {
4518 sink[_close]();
4519 }
4520 }
4521 }
4522 dart.setSignature(_TakeWhileStream, {
4523 constructors: () => ({_TakeWhileStream: [_TakeWhileStream$(T), [Stream$(T) , dart.functionType(core.bool, [T])]]}),
4524 methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
4525 });
4526 return _TakeWhileStream;
4527 });
4528 let _TakeWhileStream = _TakeWhileStream$();
4529 let _SkipStream$ = dart.generic(function(T) {
4530 class _SkipStream extends _ForwardingStream$(T, T) {
4531 _SkipStream(source, count) {
4532 this[_remaining] = count;
4533 super._ForwardingStream(source);
4534 if (!(typeof count == 'number') || dart.notNull(count) < 0)
4535 dart.throw(new core.ArgumentError(count));
4536 }
4537 [_handleData](inputEvent, sink) {
4538 dart.as(inputEvent, T);
4539 dart.as(sink, _EventSink$(T));
4540 if (dart.notNull(this[_remaining]) > 0) {
4541 this[_remaining] = dart.notNull(this[_remaining]) - 1;
4542 return;
4543 }
4544 sink[_add](inputEvent);
4545 }
4546 }
4547 dart.setSignature(_SkipStream, {
4548 constructors: () => ({_SkipStream: [_SkipStream$(T), [Stream$(T), core.int ]]}),
4549 methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
4550 });
4551 return _SkipStream;
4552 });
4553 let _SkipStream = _SkipStream$();
4554 let _hasFailed = Symbol('_hasFailed');
4555 let _SkipWhileStream$ = dart.generic(function(T) {
4556 class _SkipWhileStream extends _ForwardingStream$(T, T) {
4557 _SkipWhileStream(source, test) {
4558 this[_test] = test;
4559 this[_hasFailed] = false;
4560 super._ForwardingStream(source);
4561 }
4562 [_handleData](inputEvent, sink) {
4563 dart.as(inputEvent, T);
4564 dart.as(sink, _EventSink$(T));
4565 if (dart.notNull(this[_hasFailed])) {
4566 sink[_add](inputEvent);
4567 return;
4568 }
4569 let satisfies = null;
4570 try {
4571 satisfies = this[_test](inputEvent);
4572 } catch (e) {
4573 let s = dart.stackTrace(e);
4574 _addErrorWithReplacement(sink, e, s);
4575 this[_hasFailed] = true;
4576 return;
4577 }
4578
4579 if (!dart.notNull(satisfies)) {
4580 this[_hasFailed] = true;
4581 sink[_add](inputEvent);
4582 }
4583 }
4584 }
4585 dart.setSignature(_SkipWhileStream, {
4586 constructors: () => ({_SkipWhileStream: [_SkipWhileStream$(T), [Stream$(T) , dart.functionType(core.bool, [T])]]}),
4587 methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
4588 });
4589 return _SkipWhileStream;
4590 });
4591 let _SkipWhileStream = _SkipWhileStream$();
4592 let _Equality$ = dart.generic(function(T) {
4593 let _Equality = dart.typedef('_Equality', () => dart.functionType(core.bool, [T, T]));
4594 return _Equality;
4595 });
4596 let _Equality = _Equality$();
4597 let _equals = Symbol('_equals');
4598 let _DistinctStream$ = dart.generic(function(T) {
4599 class _DistinctStream extends _ForwardingStream$(T, T) {
4600 _DistinctStream(source, equals) {
4601 this[_previous] = _DistinctStream$()._SENTINEL;
4602 this[_equals] = equals;
4603 super._ForwardingStream(source);
4604 }
4605 [_handleData](inputEvent, sink) {
4606 dart.as(inputEvent, T);
4607 dart.as(sink, _EventSink$(T));
4608 if (dart.notNull(core.identical(this[_previous], _DistinctStream$()._SEN TINEL))) {
4609 this[_previous] = inputEvent;
4610 return sink[_add](inputEvent);
4611 } else {
4612 let isEqual = null;
4613 try {
4614 if (this[_equals] == null) {
4615 isEqual = dart.equals(this[_previous], inputEvent);
4616 } else {
4617 isEqual = this[_equals](dart.as(this[_previous], T), inputEvent);
4618 }
4619 } catch (e) {
4620 let s = dart.stackTrace(e);
4621 _addErrorWithReplacement(sink, e, s);
4622 return null;
4623 }
4624
4625 if (!dart.notNull(isEqual)) {
4626 sink[_add](inputEvent);
4627 this[_previous] = inputEvent;
4628 }
4629 }
4630 }
4631 }
4632 dart.setSignature(_DistinctStream, {
4633 constructors: () => ({_DistinctStream: [_DistinctStream$(T), [Stream$(T), dart.functionType(core.bool, [T, T])]]}),
4634 methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
4635 });
4636 return _DistinctStream;
4637 });
4638 let _DistinctStream = _DistinctStream$();
4639 dart.defineLazyProperties(_DistinctStream, {
4640 get _SENTINEL() {
4641 return new core.Object();
4642 },
4643 set _SENTINEL(_) {}
4644 });
4645 let _EventSinkWrapper$ = dart.generic(function(T) {
4646 class _EventSinkWrapper extends core.Object {
4647 _EventSinkWrapper(sink) {
4648 this[_sink] = sink;
4649 }
4650 add(data) {
4651 dart.as(data, T);
4652 this[_sink][_add](data);
4653 }
4654 addError(error, stackTrace) {
4655 if (stackTrace === void 0)
4656 stackTrace = null;
4657 this[_sink][_addError](error, stackTrace);
4658 }
4659 close() {
4660 this[_sink][_close]();
4661 }
4662 }
4663 _EventSinkWrapper[dart.implements] = () => [EventSink$(T)];
4664 dart.setSignature(_EventSinkWrapper, {
4665 constructors: () => ({_EventSinkWrapper: [_EventSinkWrapper$(T), [_EventSi nk]]}),
4666 methods: () => ({
4667 add: [dart.void, [T]],
4668 addError: [dart.void, [dart.dynamic], [core.StackTrace]],
4669 close: [dart.void, []]
4670 })
4671 });
4672 return _EventSinkWrapper;
4673 });
4674 let _EventSinkWrapper = _EventSinkWrapper$();
4675 let _transformerSink = Symbol('_transformerSink');
4676 let _isSubscribed = Symbol('_isSubscribed');
4677 let _SinkTransformerStreamSubscription$ = dart.generic(function(S, T) {
4678 class _SinkTransformerStreamSubscription extends _BufferingStreamSubscriptio n$(T) {
4679 _SinkTransformerStreamSubscription(source, mapper, onData, onError, onDone , cancelOnError) {
4680 this[_transformerSink] = null;
4681 this[_subscription] = null;
4682 super._BufferingStreamSubscription(onData, onError, onDone, cancelOnErro r);
4683 let eventSink = new (_EventSinkWrapper$(T))(this);
4684 this[_transformerSink] = mapper(eventSink);
4685 this[_subscription] = source.listen(dart.bind(this, _handleData), {onErr or: dart.bind(this, _handleError), onDone: dart.bind(this, _handleDone)});
4686 }
4687 get [_isSubscribed]() {
4688 return this[_subscription] != null;
4689 }
4690 [_add](data) {
4691 dart.as(data, T);
4692 if (dart.notNull(this[_isClosed])) {
4693 dart.throw(new core.StateError("Stream is already closed"));
4694 }
4695 super[_add](data);
4696 }
4697 [_addError](error, stackTrace) {
4698 if (dart.notNull(this[_isClosed])) {
4699 dart.throw(new core.StateError("Stream is already closed"));
4700 }
4701 super[_addError](error, stackTrace);
4702 }
4703 [_close]() {
4704 if (dart.notNull(this[_isClosed])) {
4705 dart.throw(new core.StateError("Stream is already closed"));
4706 }
4707 super[_close]();
4708 }
4709 [_onPause]() {
4710 if (dart.notNull(this[_isSubscribed]))
4711 this[_subscription].pause();
4712 }
4713 [_onResume]() {
4714 if (dart.notNull(this[_isSubscribed]))
4715 this[_subscription].resume();
4716 }
4717 [_onCancel]() {
4718 if (dart.notNull(this[_isSubscribed])) {
4719 let subscription = this[_subscription];
4720 this[_subscription] = null;
4721 subscription.cancel();
4722 }
4723 return null;
4724 }
4725 [_handleData](data) {
4726 dart.as(data, S);
4727 try {
4728 this[_transformerSink].add(data);
4729 } catch (e) {
4730 let s = dart.stackTrace(e);
4731 this[_addError](e, s);
4732 }
4733
4734 }
4735 [_handleError](error, stackTrace) {
4736 if (stackTrace === void 0)
4737 stackTrace = null;
4738 try {
4739 this[_transformerSink].addError(error, dart.as(stackTrace, core.StackT race));
4740 } catch (e) {
4741 let s = dart.stackTrace(e);
4742 if (dart.notNull(core.identical(e, error))) {
4743 this[_addError](error, dart.as(stackTrace, core.StackTrace));
4744 } else {
4745 this[_addError](e, s);
4746 }
4747 }
4748
4749 }
4750 [_handleDone]() {
4751 try {
4752 this[_subscription] = null;
4753 this[_transformerSink].close();
4754 } catch (e) {
4755 let s = dart.stackTrace(e);
4756 this[_addError](e, s);
4757 }
4758
4759 }
4760 }
4761 dart.setSignature(_SinkTransformerStreamSubscription, {
4762 constructors: () => ({_SinkTransformerStreamSubscription: [_SinkTransforme rStreamSubscription$(S, T), [Stream$(S), _SinkMapper$(S, T), dart.functionType(d art.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]]}),
4763 methods: () => ({
4764 [_add]: [dart.void, [T]],
4765 [_handleData]: [dart.void, [S]],
4766 [_handleError]: [dart.void, [dart.dynamic], [dart.dynamic]],
4767 [_handleDone]: [dart.void, []]
4768 })
4769 });
4770 return _SinkTransformerStreamSubscription;
4771 });
4772 let _SinkTransformerStreamSubscription = _SinkTransformerStreamSubscription$() ;
4773 let _SinkMapper$ = dart.generic(function(S, T) {
4774 let _SinkMapper = dart.typedef('_SinkMapper', () => dart.functionType(EventS ink$(S), [EventSink$(T)]));
4775 return _SinkMapper;
4776 });
4777 let _SinkMapper = _SinkMapper$();
4778 let _sinkMapper = Symbol('_sinkMapper');
4779 let _StreamSinkTransformer$ = dart.generic(function(S, T) {
4780 class _StreamSinkTransformer extends core.Object {
4781 _StreamSinkTransformer(sinkMapper) {
4782 this[_sinkMapper] = sinkMapper;
4783 }
4784 bind(stream) {
4785 dart.as(stream, Stream$(S));
4786 return new (_BoundSinkStream$(S, T))(stream, this[_sinkMapper]);
4787 }
4788 }
4789 _StreamSinkTransformer[dart.implements] = () => [StreamTransformer$(S, T)];
4790 dart.setSignature(_StreamSinkTransformer, {
4791 constructors: () => ({_StreamSinkTransformer: [_StreamSinkTransformer$(S, T), [_SinkMapper$(S, T)]]}),
4792 methods: () => ({bind: [Stream$(T), [Stream$(S)]]})
4793 });
4794 return _StreamSinkTransformer;
4795 });
4796 let _StreamSinkTransformer = _StreamSinkTransformer$();
4797 let _BoundSinkStream$ = dart.generic(function(S, T) {
4798 class _BoundSinkStream extends Stream$(T) {
4799 get isBroadcast() {
4800 return this[_stream].isBroadcast;
4801 }
4802 _BoundSinkStream(stream, sinkMapper) {
4803 this[_stream] = stream;
4804 this[_sinkMapper] = sinkMapper;
4805 super.Stream();
4806 }
4807 listen(onData, opts) {
4808 dart.as(onData, dart.functionType(dart.void, [T]));
4809 let onError = opts && 'onError' in opts ? opts.onError : null;
4810 let onDone = opts && 'onDone' in opts ? opts.onDone : null;
4811 dart.as(onDone, dart.functionType(dart.void, []));
4812 let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
4813 cancelOnError = core.identical(true, cancelOnError);
4814 let subscription = new (_SinkTransformerStreamSubscription$(dart.dynamic , T))(this[_stream], dart.as(this[_sinkMapper], _SinkMapper), onData, onError, o nDone, cancelOnError);
4815 return subscription;
4816 }
4817 }
4818 dart.setSignature(_BoundSinkStream, {
4819 constructors: () => ({_BoundSinkStream: [_BoundSinkStream$(S, T), [Stream$ (S), _SinkMapper$(S, T)]]}),
4820 methods: () => ({listen: [StreamSubscription$(T), [dart.functionType(dart. void, [T])], {onError: core.Function, onDone: dart.functionType(dart.void, []), cancelOnError: core.bool}]})
4821 });
4822 return _BoundSinkStream;
4823 });
4824 let _BoundSinkStream = _BoundSinkStream$();
4825 let _TransformDataHandler$ = dart.generic(function(S, T) {
4826 let _TransformDataHandler = dart.typedef('_TransformDataHandler', () => dart .functionType(dart.void, [S, EventSink$(T)]));
4827 return _TransformDataHandler;
4828 });
4829 let _TransformDataHandler = _TransformDataHandler$();
4830 let _TransformErrorHandler$ = dart.generic(function(T) {
4831 let _TransformErrorHandler = dart.typedef('_TransformErrorHandler', () => da rt.functionType(dart.void, [core.Object, core.StackTrace, EventSink$(T)]));
4832 return _TransformErrorHandler;
4833 });
4834 let _TransformErrorHandler = _TransformErrorHandler$();
4835 let _TransformDoneHandler$ = dart.generic(function(T) {
4836 let _TransformDoneHandler = dart.typedef('_TransformDoneHandler', () => dart .functionType(dart.void, [EventSink$(T)]));
4837 return _TransformDoneHandler;
4838 });
4839 let _TransformDoneHandler = _TransformDoneHandler$();
4840 let _HandlerEventSink$ = dart.generic(function(S, T) {
4841 class _HandlerEventSink extends core.Object {
4842 _HandlerEventSink(handleData, handleError, handleDone, sink) {
4843 this[_handleData] = handleData;
4844 this[_handleError] = handleError;
4845 this[_handleDone] = handleDone;
4846 this[_sink] = sink;
4847 }
4848 add(data) {
4849 dart.as(data, S);
4850 return this[_handleData](data, this[_sink]);
4851 }
4852 addError(error, stackTrace) {
4853 if (stackTrace === void 0)
4854 stackTrace = null;
4855 return this[_handleError](error, stackTrace, this[_sink]);
4856 }
4857 close() {
4858 return this[_handleDone](this[_sink]);
4859 }
4860 }
4861 _HandlerEventSink[dart.implements] = () => [EventSink$(S)];
4862 dart.setSignature(_HandlerEventSink, {
4863 constructors: () => ({_HandlerEventSink: [_HandlerEventSink$(S, T), [_Tran sformDataHandler$(S, T), _TransformErrorHandler$(T), _TransformDoneHandler$(T), EventSink$(T)]]}),
4864 methods: () => ({
4865 add: [dart.void, [S]],
4866 addError: [dart.void, [core.Object], [core.StackTrace]],
4867 close: [dart.void, []]
4868 })
4869 });
4870 return _HandlerEventSink;
4871 });
4872 let _HandlerEventSink = _HandlerEventSink$();
4873 let _StreamHandlerTransformer$ = dart.generic(function(S, T) {
4874 class _StreamHandlerTransformer extends _StreamSinkTransformer$(S, T) {
4875 _StreamHandlerTransformer(opts) {
4876 let handleData = opts && 'handleData' in opts ? opts.handleData : null;
4877 let handleError = opts && 'handleError' in opts ? opts.handleError : nul l;
4878 let handleDone = opts && 'handleDone' in opts ? opts.handleDone : null;
4879 super._StreamSinkTransformer(dart.as(dart.fn(outputSink => {
4880 dart.as(outputSink, EventSink$(T));
4881 if (handleData == null)
4882 handleData = dart.as(_StreamHandlerTransformer$()._defaultHandleData , __CastType27);
4883 if (handleError == null)
4884 handleError = dart.as(_StreamHandlerTransformer$()._defaultHandleErr or, __CastType30);
4885 if (handleDone == null)
4886 handleDone = _StreamHandlerTransformer$()._defaultHandleDone;
4887 return new (_HandlerEventSink$(S, T))(handleData, handleError, handleD one, outputSink);
4888 }, dart.dynamic, [EventSink$(T)]), _SinkMapper$(S, T)));
4889 }
4890 bind(stream) {
4891 dart.as(stream, Stream$(S));
4892 return super.bind(stream);
4893 }
4894 static _defaultHandleData(data, sink) {
4895 sink.add(data);
4896 }
4897 static _defaultHandleError(error, stackTrace, sink) {
4898 sink.addError(error);
4899 }
4900 static _defaultHandleDone(sink) {
4901 sink.close();
4902 }
4903 }
4904 dart.setSignature(_StreamHandlerTransformer, {
4905 constructors: () => ({_StreamHandlerTransformer: [_StreamHandlerTransforme r$(S, T), [], {handleData: dart.functionType(dart.void, [S, EventSink$(T)]), han dleError: dart.functionType(dart.void, [core.Object, core.StackTrace, EventSink$ (T)]), handleDone: dart.functionType(dart.void, [EventSink$(T)])}]}),
4906 methods: () => ({bind: [Stream$(T), [Stream$(S)]]}),
4907 statics: () => ({
4908 _defaultHandleData: [dart.void, [dart.dynamic, EventSink]],
4909 _defaultHandleError: [dart.void, [dart.dynamic, core.StackTrace, EventSi nk]],
4910 _defaultHandleDone: [dart.void, [EventSink]]
4911 }),
4912 names: ['_defaultHandleData', '_defaultHandleError', '_defaultHandleDone']
4913 });
4914 return _StreamHandlerTransformer;
4915 });
4916 let _StreamHandlerTransformer = _StreamHandlerTransformer$();
4917 let _SubscriptionTransformer$ = dart.generic(function(S, T) {
4918 let _SubscriptionTransformer = dart.typedef('_SubscriptionTransformer', () = > dart.functionType(StreamSubscription$(T), [Stream$(S), core.bool]));
4919 return _SubscriptionTransformer;
4920 });
4921 let _SubscriptionTransformer = _SubscriptionTransformer$();
4922 let _transformer = Symbol('_transformer');
4923 let _StreamSubscriptionTransformer$ = dart.generic(function(S, T) {
4924 class _StreamSubscriptionTransformer extends core.Object {
4925 _StreamSubscriptionTransformer(transformer) {
4926 this[_transformer] = transformer;
4927 }
4928 bind(stream) {
4929 dart.as(stream, Stream$(S));
4930 return new (_BoundSubscriptionStream$(S, T))(stream, this[_transformer]) ;
4931 }
4932 }
4933 _StreamSubscriptionTransformer[dart.implements] = () => [StreamTransformer$( S, T)];
4934 dart.setSignature(_StreamSubscriptionTransformer, {
4935 constructors: () => ({_StreamSubscriptionTransformer: [_StreamSubscription Transformer$(S, T), [_SubscriptionTransformer$(S, T)]]}),
4936 methods: () => ({bind: [Stream$(T), [Stream$(S)]]})
4937 });
4938 return _StreamSubscriptionTransformer;
4939 });
4940 let _StreamSubscriptionTransformer = _StreamSubscriptionTransformer$();
4941 let _BoundSubscriptionStream$ = dart.generic(function(S, T) {
4942 class _BoundSubscriptionStream extends Stream$(T) {
4943 _BoundSubscriptionStream(stream, transformer) {
4944 this[_stream] = stream;
4945 this[_transformer] = transformer;
4946 super.Stream();
4947 }
4948 listen(onData, opts) {
4949 dart.as(onData, dart.functionType(dart.void, [T]));
4950 let onError = opts && 'onError' in opts ? opts.onError : null;
4951 let onDone = opts && 'onDone' in opts ? opts.onDone : null;
4952 dart.as(onDone, dart.functionType(dart.void, []));
4953 let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
4954 cancelOnError = core.identical(true, cancelOnError);
4955 let result = this[_transformer](this[_stream], cancelOnError);
4956 result.onData(onData);
4957 result.onError(onError);
4958 result.onDone(onDone);
4959 return result;
4960 }
4961 }
4962 dart.setSignature(_BoundSubscriptionStream, {
4963 constructors: () => ({_BoundSubscriptionStream: [_BoundSubscriptionStream$ (S, T), [Stream$(S), _SubscriptionTransformer$(S, T)]]}),
4964 methods: () => ({listen: [StreamSubscription$(T), [dart.functionType(dart. void, [T])], {onError: core.Function, onDone: dart.functionType(dart.void, []), cancelOnError: core.bool}]})
4965 });
4966 return _BoundSubscriptionStream;
4967 });
4968 let _BoundSubscriptionStream = _BoundSubscriptionStream$();
4969 let __CastType27$ = dart.generic(function(S, T) {
4970 let __CastType27 = dart.typedef('__CastType27', () => dart.functionType(dart .void, [S, EventSink$(T)]));
4971 return __CastType27;
4972 });
4973 let __CastType27 = __CastType27$();
4974 let __CastType30$ = dart.generic(function(T) {
4975 let __CastType30 = dart.typedef('__CastType30', () => dart.functionType(dart .void, [core.Object, core.StackTrace, EventSink$(T)]));
4976 return __CastType30;
4977 });
4978 let __CastType30 = __CastType30$();
4979 class Timer extends core.Object {
4980 static new(duration, callback) {
4981 if (dart.equals(Zone.current, Zone.ROOT)) {
4982 return Zone.current.createTimer(duration, callback);
4983 }
4984 return Zone.current.createTimer(duration, Zone.current.bindCallback(callba ck, {runGuarded: true}));
4985 }
4986 static periodic(duration, callback) {
4987 if (dart.equals(Zone.current, Zone.ROOT)) {
4988 return Zone.current.createPeriodicTimer(duration, callback);
4989 }
4990 return Zone.current.createPeriodicTimer(duration, dart.as(Zone.current.bin dUnaryCallback(callback, {runGuarded: true}), __CastType34));
4991 }
4992 static run(callback) {
4993 Timer.new(core.Duration.ZERO, callback);
4994 }
4995 static _createTimer(duration, callback) {
4996 let milliseconds = duration.inMilliseconds;
4997 if (dart.notNull(milliseconds) < 0)
4998 milliseconds = 0;
4999 return new _isolate_helper.TimerImpl(milliseconds, callback);
5000 }
5001 static _createPeriodicTimer(duration, callback) {
5002 let milliseconds = duration.inMilliseconds;
5003 if (dart.notNull(milliseconds) < 0)
5004 milliseconds = 0;
5005 return new _isolate_helper.TimerImpl.periodic(milliseconds, callback);
5006 }
5007 }
5008 dart.setSignature(Timer, {
5009 constructors: () => ({
5010 new: [Timer, [core.Duration, dart.functionType(dart.void, [])]],
5011 periodic: [Timer, [core.Duration, dart.functionType(dart.void, [Timer])]]
5012 }),
5013 statics: () => ({
5014 run: [dart.void, [dart.functionType(dart.void, [])]],
5015 _createTimer: [Timer, [core.Duration, dart.functionType(dart.void, [])]],
5016 _createPeriodicTimer: [Timer, [core.Duration, dart.functionType(dart.void, [Timer])]]
5017 }),
5018 names: ['run', '_createTimer', '_createPeriodicTimer']
5019 });
5020 let __CastType34 = dart.typedef('__CastType34', () => dart.functionType(dart.v oid, [Timer]));
5021 let ZoneCallback = dart.typedef('ZoneCallback', () => dart.functionType(dart.d ynamic, []));
5022 let ZoneUnaryCallback = dart.typedef('ZoneUnaryCallback', () => dart.functionT ype(dart.dynamic, [dart.dynamic]));
5023 let ZoneBinaryCallback = dart.typedef('ZoneBinaryCallback', () => dart.functio nType(dart.dynamic, [dart.dynamic, dart.dynamic]));
5024 let HandleUncaughtErrorHandler = dart.typedef('HandleUncaughtErrorHandler', () => dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.dynamic, cor e.StackTrace]));
5025 let RunHandler = dart.typedef('RunHandler', () => dart.functionType(dart.dynam ic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]));
5026 let RunUnaryHandler = dart.typedef('RunUnaryHandler', () => dart.functionType( dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.d ynamic]), dart.dynamic]));
5027 let RunBinaryHandler = dart.typedef('RunBinaryHandler', () => dart.functionTyp e(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart .dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]));
5028 let RegisterCallbackHandler = dart.typedef('RegisterCallbackHandler', () => da rt.functionType(ZoneCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart. dynamic, [])]));
5029 let RegisterUnaryCallbackHandler = dart.typedef('RegisterUnaryCallbackHandler' , () => dart.functionType(ZoneUnaryCallback, [Zone, ZoneDelegate, Zone, dart.fun ctionType(dart.dynamic, [dart.dynamic])]));
5030 let RegisterBinaryCallbackHandler = dart.typedef('RegisterBinaryCallbackHandle r', () => dart.functionType(ZoneBinaryCallback, [Zone, ZoneDelegate, Zone, dart. functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]));
5031 let ErrorCallbackHandler = dart.typedef('ErrorCallbackHandler', () => dart.fun ctionType(AsyncError, [Zone, ZoneDelegate, Zone, core.Object, core.StackTrace])) ;
5032 let ScheduleMicrotaskHandler = dart.typedef('ScheduleMicrotaskHandler', () => dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, dart.functionType(dart.d ynamic, [])]));
5033 let CreateTimerHandler = dart.typedef('CreateTimerHandler', () => dart.functio nType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.vo id, [])]));
5034 let CreatePeriodicTimerHandler = dart.typedef('CreatePeriodicTimerHandler', () => dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.func tionType(dart.void, [Timer])]));
5035 let PrintHandler = dart.typedef('PrintHandler', () => dart.functionType(dart.v oid, [Zone, ZoneDelegate, Zone, core.String]));
5036 let ForkHandler = dart.typedef('ForkHandler', () => dart.functionType(Zone, [Z one, ZoneDelegate, Zone, ZoneSpecification, core.Map]));
5037 class _ZoneFunction extends core.Object {
5038 _ZoneFunction(zone, func) {
5039 this.zone = zone;
5040 this.function = func;
5041 }
5042 }
5043 dart.setSignature(_ZoneFunction, {
5044 constructors: () => ({_ZoneFunction: [_ZoneFunction, [_Zone, core.Function]] })
5045 });
5046 class ZoneSpecification extends core.Object {
5047 static new(opts) {
5048 return new _ZoneSpecification(opts);
5049 }
5050 static from(other, opts) {
5051 let handleUncaughtError = opts && 'handleUncaughtError' in opts ? opts.han dleUncaughtError : null;
5052 let run = opts && 'run' in opts ? opts.run : null;
5053 let runUnary = opts && 'runUnary' in opts ? opts.runUnary : null;
5054 let runBinary = opts && 'runBinary' in opts ? opts.runBinary : null;
5055 let registerCallback = opts && 'registerCallback' in opts ? opts.registerC allback : null;
5056 let registerUnaryCallback = opts && 'registerUnaryCallback' in opts ? opts .registerUnaryCallback : null;
5057 let registerBinaryCallback = opts && 'registerBinaryCallback' in opts ? op ts.registerBinaryCallback : null;
5058 let errorCallback = opts && 'errorCallback' in opts ? opts.errorCallback : null;
5059 let scheduleMicrotask = opts && 'scheduleMicrotask' in opts ? opts.schedul eMicrotask : null;
5060 let createTimer = opts && 'createTimer' in opts ? opts.createTimer : null;
5061 let createPeriodicTimer = opts && 'createPeriodicTimer' in opts ? opts.cre atePeriodicTimer : null;
5062 let print = opts && 'print' in opts ? opts.print : null;
5063 let fork = opts && 'fork' in opts ? opts.fork : null;
5064 return ZoneSpecification.new({handleUncaughtError: handleUncaughtError != null ? handleUncaughtError : other.handleUncaughtError, run: run != null ? run : other.run, runUnary: runUnary != null ? runUnary : other.runUnary, runBinary: r unBinary != null ? runBinary : other.runBinary, registerCallback: registerCallba ck != null ? registerCallback : other.registerCallback, registerUnaryCallback: r egisterUnaryCallback != null ? registerUnaryCallback : other.registerUnaryCallba ck, registerBinaryCallback: registerBinaryCallback != null ? registerBinaryCallb ack : other.registerBinaryCallback, errorCallback: errorCallback != null ? error Callback : other.errorCallback, scheduleMicrotask: scheduleMicrotask != null ? s cheduleMicrotask : other.scheduleMicrotask, createTimer: createTimer != null ? c reateTimer : other.createTimer, createPeriodicTimer: createPeriodicTimer != null ? createPeriodicTimer : other.createPeriodicTimer, print: print != null ? print : other.print, fork: fork != null ? fork : other.fork});
5065 }
5066 }
5067 dart.setSignature(ZoneSpecification, {
5068 constructors: () => ({
5069 new: [ZoneSpecification, [], {handleUncaughtError: dart.functionType(dart. dynamic, [Zone, ZoneDelegate, Zone, dart.dynamic, core.StackTrace]), run: dart.f unctionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dyna mic, [])]), runUnary: dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]), runBinary: dar t.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.d ynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]), registerCal lback: dart.functionType(ZoneCallback, [Zone, ZoneDelegate, Zone, dart.functionT ype(dart.dynamic, [])]), registerUnaryCallback: dart.functionType(ZoneUnaryCallb ack, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic])] ), registerBinaryCallback: dart.functionType(ZoneBinaryCallback, [Zone, ZoneDele gate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]), err orCallback: dart.functionType(AsyncError, [Zone, ZoneDelegate, Zone, core.Object , core.StackTrace]), scheduleMicrotask: dart.functionType(dart.void, [Zone, Zone Delegate, Zone, dart.functionType(dart.dynamic, [])]), createTimer: dart.functio nType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.vo id, [])]), createPeriodicTimer: dart.functionType(Timer, [Zone, ZoneDelegate, Zo ne, core.Duration, dart.functionType(dart.void, [Timer])]), print: dart.function Type(dart.void, [Zone, ZoneDelegate, Zone, core.String]), fork: dart.functionTyp e(Zone, [Zone, ZoneDelegate, Zone, ZoneSpecification, core.Map])}],
5070 from: [ZoneSpecification, [ZoneSpecification], {handleUncaughtError: dart. functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.dynamic, core.StackTr ace]), run: dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.func tionType(dart.dynamic, [])]), runUnary: dart.functionType(dart.dynamic, [Zone, Z oneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic ]), runBinary: dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.f unctionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dyna mic]), registerCallback: dart.functionType(ZoneCallback, [Zone, ZoneDelegate, Zo ne, dart.functionType(dart.dynamic, [])]), registerUnaryCallback: dart.functionT ype(ZoneUnaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic , [dart.dynamic])]), registerBinaryCallback: dart.functionType(ZoneBinaryCallbac k, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dar t.dynamic])]), errorCallback: dart.functionType(AsyncError, [Zone, ZoneDelegate, Zone, core.Object, core.StackTrace]), scheduleMicrotask: dart.functionType(dart .void, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]), createT imer: dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.fu nctionType(dart.void, [])]), createPeriodicTimer: dart.functionType(Timer, [Zone , ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [Timer])]), pr int: dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, core.String]), fork : dart.functionType(Zone, [Zone, ZoneDelegate, Zone, ZoneSpecification, core.Map ])}]
5071 })
5072 });
5073 class _ZoneSpecification extends core.Object {
5074 _ZoneSpecification(opts) {
5075 let handleUncaughtError = opts && 'handleUncaughtError' in opts ? opts.han dleUncaughtError : null;
5076 let run = opts && 'run' in opts ? opts.run : null;
5077 let runUnary = opts && 'runUnary' in opts ? opts.runUnary : null;
5078 let runBinary = opts && 'runBinary' in opts ? opts.runBinary : null;
5079 let registerCallback = opts && 'registerCallback' in opts ? opts.registerC allback : null;
5080 let registerUnaryCallback = opts && 'registerUnaryCallback' in opts ? opts .registerUnaryCallback : null;
5081 let registerBinaryCallback = opts && 'registerBinaryCallback' in opts ? op ts.registerBinaryCallback : null;
5082 let errorCallback = opts && 'errorCallback' in opts ? opts.errorCallback : null;
5083 let scheduleMicrotask = opts && 'scheduleMicrotask' in opts ? opts.schedul eMicrotask : null;
5084 let createTimer = opts && 'createTimer' in opts ? opts.createTimer : null;
5085 let createPeriodicTimer = opts && 'createPeriodicTimer' in opts ? opts.cre atePeriodicTimer : null;
5086 let print = opts && 'print' in opts ? opts.print : null;
5087 let fork = opts && 'fork' in opts ? opts.fork : null;
5088 this.handleUncaughtError = handleUncaughtError;
5089 this.run = run;
5090 this.runUnary = runUnary;
5091 this.runBinary = runBinary;
5092 this.registerCallback = registerCallback;
5093 this.registerUnaryCallback = registerUnaryCallback;
5094 this.registerBinaryCallback = registerBinaryCallback;
5095 this.errorCallback = errorCallback;
5096 this.scheduleMicrotask = scheduleMicrotask;
5097 this.createTimer = createTimer;
5098 this.createPeriodicTimer = createPeriodicTimer;
5099 this.print = print;
5100 this.fork = fork;
5101 }
5102 }
5103 _ZoneSpecification[dart.implements] = () => [ZoneSpecification];
5104 dart.setSignature(_ZoneSpecification, {
5105 constructors: () => ({_ZoneSpecification: [_ZoneSpecification, [], {handleUn caughtError: HandleUncaughtErrorHandler, run: RunHandler, runUnary: RunUnaryHand ler, runBinary: RunBinaryHandler, registerCallback: RegisterCallbackHandler, reg isterUnaryCallback: RegisterUnaryCallbackHandler, registerBinaryCallback: Regist erBinaryCallbackHandler, errorCallback: ErrorCallbackHandler, scheduleMicrotask: ScheduleMicrotaskHandler, createTimer: CreateTimerHandler, createPeriodicTimer: CreatePeriodicTimerHandler, print: PrintHandler, fork: ForkHandler}]})
5106 });
5107 class ZoneDelegate extends core.Object {}
5108 class Zone extends core.Object {
5109 _() {
5110 }
5111 static get current() {
5112 return Zone._current;
5113 }
5114 static _enter(zone) {
5115 dart.assert(zone != null);
5116 dart.assert(!dart.notNull(core.identical(zone, Zone._current)));
5117 let previous = Zone._current;
5118 Zone._current = zone;
5119 return previous;
5120 }
5121 static _leave(previous) {
5122 dart.assert(previous != null);
5123 Zone._current = previous;
5124 }
5125 }
5126 dart.defineNamedConstructor(Zone, '_');
5127 dart.setSignature(Zone, {
5128 constructors: () => ({_: [Zone, []]}),
5129 statics: () => ({
5130 _enter: [Zone, [Zone]],
5131 _leave: [dart.void, [Zone]]
5132 }),
5133 names: ['_enter', '_leave']
5134 });
5135 class _Zone extends core.Object {
5136 _Zone() {
5137 }
5138 inSameErrorZone(otherZone) {
5139 return dart.notNull(core.identical(this, otherZone)) || dart.notNull(core. identical(this.errorZone, otherZone.errorZone));
5140 }
5141 }
5142 _Zone[dart.implements] = () => [Zone];
5143 dart.setSignature(_Zone, {
5144 constructors: () => ({_Zone: [_Zone, []]}),
5145 methods: () => ({inSameErrorZone: [core.bool, [Zone]]})
5146 });
5147 let _run = Symbol('_run');
5148 let _runUnary = Symbol('_runUnary');
5149 let _runBinary = Symbol('_runBinary');
5150 let _registerCallback = Symbol('_registerCallback');
5151 let _registerUnaryCallback = Symbol('_registerUnaryCallback');
5152 let _registerBinaryCallback = Symbol('_registerBinaryCallback');
5153 let _errorCallback = Symbol('_errorCallback');
5154 let _scheduleMicrotask = Symbol('_scheduleMicrotask');
5155 let _createTimer = Symbol('_createTimer');
5156 let _createPeriodicTimer = Symbol('_createPeriodicTimer');
5157 let _print = Symbol('_print');
5158 let _fork = Symbol('_fork');
5159 let _handleUncaughtError = Symbol('_handleUncaughtError');
5160 let _map = Symbol('_map');
5161 let _delegate = Symbol('_delegate');
5162 class _RootZone extends _Zone {
5163 _RootZone() {
5164 super._Zone();
5165 }
5166 get [_run]() {
5167 return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRun));
5168 }
5169 get [_runUnary]() {
5170 return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRunUnary));
5171 }
5172 get [_runBinary]() {
5173 return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRunBinary));
5174 }
5175 get [_registerCallback]() {
5176 return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRegisterCallback));
5177 }
5178 get [_registerUnaryCallback]() {
5179 return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRegisterUnaryCallback ));
5180 }
5181 get [_registerBinaryCallback]() {
5182 return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRegisterBinaryCallbac k));
5183 }
5184 get [_errorCallback]() {
5185 return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootErrorCallback));
5186 }
5187 get [_scheduleMicrotask]() {
5188 return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootScheduleMicrotask));
5189 }
5190 get [_createTimer]() {
5191 return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootCreateTimer));
5192 }
5193 get [_createPeriodicTimer]() {
5194 return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootCreatePeriodicTimer)) ;
5195 }
5196 get [_print]() {
5197 return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootPrint));
5198 }
5199 get [_fork]() {
5200 return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootFork));
5201 }
5202 get [_handleUncaughtError]() {
5203 return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootHandleUncaughtError)) ;
5204 }
5205 get parent() {
5206 return null;
5207 }
5208 get [_map]() {
5209 return _RootZone._rootMap;
5210 }
5211 get [_delegate]() {
5212 if (_RootZone._rootDelegate != null)
5213 return _RootZone._rootDelegate;
5214 return _RootZone._rootDelegate = new _ZoneDelegate(this);
5215 }
5216 get errorZone() {
5217 return this;
5218 }
5219 runGuarded(f) {
5220 try {
5221 if (dart.notNull(core.identical(_ROOT_ZONE, Zone._current))) {
5222 return f();
5223 }
5224 return _rootRun(null, null, this, f);
5225 } catch (e) {
5226 let s = dart.stackTrace(e);
5227 return this.handleUncaughtError(e, s);
5228 }
5229
5230 }
5231 runUnaryGuarded(f, arg) {
5232 try {
5233 if (dart.notNull(core.identical(_ROOT_ZONE, Zone._current))) {
5234 return dart.dcall(f, arg);
5235 }
5236 return _rootRunUnary(null, null, this, f, arg);
5237 } catch (e) {
5238 let s = dart.stackTrace(e);
5239 return this.handleUncaughtError(e, s);
5240 }
5241
5242 }
5243 runBinaryGuarded(f, arg1, arg2) {
5244 try {
5245 if (dart.notNull(core.identical(_ROOT_ZONE, Zone._current))) {
5246 return dart.dcall(f, arg1, arg2);
5247 }
5248 return _rootRunBinary(null, null, this, f, arg1, arg2);
5249 } catch (e) {
5250 let s = dart.stackTrace(e);
5251 return this.handleUncaughtError(e, s);
5252 }
5253
5254 }
5255 bindCallback(f, opts) {
5256 let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
5257 if (dart.notNull(runGuarded)) {
5258 return dart.fn((() => this.runGuarded(f)).bind(this));
5259 } else {
5260 return dart.fn((() => this.run(f)).bind(this));
5261 }
5262 }
5263 bindUnaryCallback(f, opts) {
5264 let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
5265 if (dart.notNull(runGuarded)) {
5266 return dart.fn((arg => this.runUnaryGuarded(f, arg)).bind(this));
5267 } else {
5268 return dart.fn((arg => this.runUnary(f, arg)).bind(this));
5269 }
5270 }
5271 bindBinaryCallback(f, opts) {
5272 let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
5273 if (dart.notNull(runGuarded)) {
5274 return dart.fn(((arg1, arg2) => this.runBinaryGuarded(f, arg1, arg2)).bi nd(this));
5275 } else {
5276 return dart.fn(((arg1, arg2) => this.runBinary(f, arg1, arg2)).bind(this ));
5277 }
5278 }
5279 get(key) {
5280 return null;
5281 }
5282 handleUncaughtError(error, stackTrace) {
5283 return _rootHandleUncaughtError(null, null, this, error, stackTrace);
5284 }
5285 fork(opts) {
5286 let specification = opts && 'specification' in opts ? opts.specification : null;
5287 let zoneValues = opts && 'zoneValues' in opts ? opts.zoneValues : null;
5288 return _rootFork(null, null, this, specification, zoneValues);
5289 }
5290 run(f) {
5291 if (dart.notNull(core.identical(Zone._current, _ROOT_ZONE)))
5292 return f();
5293 return _rootRun(null, null, this, f);
5294 }
5295 runUnary(f, arg) {
5296 if (dart.notNull(core.identical(Zone._current, _ROOT_ZONE)))
5297 return dart.dcall(f, arg);
5298 return _rootRunUnary(null, null, this, f, arg);
5299 }
5300 runBinary(f, arg1, arg2) {
5301 if (dart.notNull(core.identical(Zone._current, _ROOT_ZONE)))
5302 return dart.dcall(f, arg1, arg2);
5303 return _rootRunBinary(null, null, this, f, arg1, arg2);
5304 }
5305 registerCallback(f) {
5306 return f;
5307 }
5308 registerUnaryCallback(f) {
5309 return f;
5310 }
5311 registerBinaryCallback(f) {
5312 return f;
5313 }
5314 errorCallback(error, stackTrace) {
5315 return null;
5316 }
5317 scheduleMicrotask(f) {
5318 _rootScheduleMicrotask(null, null, this, f);
5319 }
5320 createTimer(duration, f) {
5321 return Timer._createTimer(duration, f);
5322 }
5323 createPeriodicTimer(duration, f) {
5324 return Timer._createPeriodicTimer(duration, f);
5325 }
5326 print(line) {
5327 _internal.printToConsole(line);
5328 }
5329 }
5330 dart.setSignature(_RootZone, {
5331 constructors: () => ({_RootZone: [_RootZone, []]}),
5332 methods: () => ({
5333 runGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [])]],
5334 runUnaryGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dyn amic]), dart.dynamic]],
5335 runBinaryGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dy namic, dart.dynamic]), dart.dynamic, dart.dynamic]],
5336 bindCallback: [ZoneCallback, [dart.functionType(dart.dynamic, [])], {runGu arded: core.bool}],
5337 bindUnaryCallback: [ZoneUnaryCallback, [dart.functionType(dart.dynamic, [d art.dynamic])], {runGuarded: core.bool}],
5338 bindBinaryCallback: [ZoneBinaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])], {runGuarded: core.bool}],
5339 get: [dart.dynamic, [core.Object]],
5340 handleUncaughtError: [dart.dynamic, [dart.dynamic, core.StackTrace]],
5341 fork: [Zone, [], {specification: ZoneSpecification, zoneValues: core.Map}] ,
5342 run: [dart.dynamic, [dart.functionType(dart.dynamic, [])]],
5343 runUnary: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]],
5344 runBinary: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]],
5345 registerCallback: [ZoneCallback, [dart.functionType(dart.dynamic, [])]],
5346 registerUnaryCallback: [ZoneUnaryCallback, [dart.functionType(dart.dynamic , [dart.dynamic])]],
5347 registerBinaryCallback: [ZoneBinaryCallback, [dart.functionType(dart.dynam ic, [dart.dynamic, dart.dynamic])]],
5348 errorCallback: [AsyncError, [core.Object, core.StackTrace]],
5349 scheduleMicrotask: [dart.void, [dart.functionType(dart.void, [])]],
5350 createTimer: [Timer, [core.Duration, dart.functionType(dart.void, [])]],
5351 createPeriodicTimer: [Timer, [core.Duration, dart.functionType(dart.void, [Timer])]],
5352 print: [dart.void, [core.String]]
5353 })
5354 });
5355 let _ROOT_ZONE = dart.const(new _RootZone());
5356 Zone.ROOT = _ROOT_ZONE;
5357 Zone._current = _ROOT_ZONE;
5358 function _parentDelegate(zone) {
5359 if (zone.parent == null)
5360 return null;
5361 return zone.parent[_delegate];
5362 }
5363 dart.fn(_parentDelegate, ZoneDelegate, [_Zone]);
5364 let _delegationTarget = Symbol('_delegationTarget');
5365 class _ZoneDelegate extends core.Object {
5366 _ZoneDelegate(delegationTarget) {
5367 this[_delegationTarget] = delegationTarget;
5368 }
5369 handleUncaughtError(zone, error, stackTrace) {
5370 let implementation = this[_delegationTarget][_handleUncaughtError];
5371 let implZone = implementation.zone;
5372 return dart.dcall(implementation.function, implZone, _parentDelegate(implZ one), zone, error, stackTrace);
5373 }
5374 run(zone, f) {
5375 let implementation = this[_delegationTarget][_run];
5376 let implZone = implementation.zone;
5377 return dart.dcall(implementation.function, implZone, _parentDelegate(implZ one), zone, f);
5378 }
5379 runUnary(zone, f, arg) {
5380 let implementation = this[_delegationTarget][_runUnary];
5381 let implZone = implementation.zone;
5382 return dart.dcall(implementation.function, implZone, _parentDelegate(implZ one), zone, f, arg);
5383 }
5384 runBinary(zone, f, arg1, arg2) {
5385 let implementation = this[_delegationTarget][_runBinary];
5386 let implZone = implementation.zone;
5387 return dart.dcall(implementation.function, implZone, _parentDelegate(implZ one), zone, f, arg1, arg2);
5388 }
5389 registerCallback(zone, f) {
5390 let implementation = this[_delegationTarget][_registerCallback];
5391 let implZone = implementation.zone;
5392 return dart.as(dart.dcall(implementation.function, implZone, _parentDelega te(implZone), zone, f), ZoneCallback);
5393 }
5394 registerUnaryCallback(zone, f) {
5395 let implementation = this[_delegationTarget][_registerUnaryCallback];
5396 let implZone = implementation.zone;
5397 return dart.as(dart.dcall(implementation.function, implZone, _parentDelega te(implZone), zone, f), ZoneUnaryCallback);
5398 }
5399 registerBinaryCallback(zone, f) {
5400 let implementation = this[_delegationTarget][_registerBinaryCallback];
5401 let implZone = implementation.zone;
5402 return dart.as(dart.dcall(implementation.function, implZone, _parentDelega te(implZone), zone, f), ZoneBinaryCallback);
5403 }
5404 errorCallback(zone, error, stackTrace) {
5405 let implementation = this[_delegationTarget][_errorCallback];
5406 let implZone = implementation.zone;
5407 if (dart.notNull(core.identical(implZone, _ROOT_ZONE)))
5408 return null;
5409 return dart.as(dart.dcall(implementation.function, implZone, _parentDelega te(implZone), zone, error, stackTrace), AsyncError);
5410 }
5411 scheduleMicrotask(zone, f) {
5412 let implementation = this[_delegationTarget][_scheduleMicrotask];
5413 let implZone = implementation.zone;
5414 dart.dcall(implementation.function, implZone, _parentDelegate(implZone), z one, f);
5415 }
5416 createTimer(zone, duration, f) {
5417 let implementation = this[_delegationTarget][_createTimer];
5418 let implZone = implementation.zone;
5419 return dart.as(dart.dcall(implementation.function, implZone, _parentDelega te(implZone), zone, duration, f), Timer);
5420 }
5421 createPeriodicTimer(zone, period, f) {
5422 let implementation = this[_delegationTarget][_createPeriodicTimer];
5423 let implZone = implementation.zone;
5424 return dart.as(dart.dcall(implementation.function, implZone, _parentDelega te(implZone), zone, period, f), Timer);
5425 }
5426 print(zone, line) {
5427 let implementation = this[_delegationTarget][_print];
5428 let implZone = implementation.zone;
5429 dart.dcall(implementation.function, implZone, _parentDelegate(implZone), z one, line);
5430 }
5431 fork(zone, specification, zoneValues) {
5432 let implementation = this[_delegationTarget][_fork];
5433 let implZone = implementation.zone;
5434 return dart.as(dart.dcall(implementation.function, implZone, _parentDelega te(implZone), zone, specification, zoneValues), Zone);
5435 }
5436 }
5437 _ZoneDelegate[dart.implements] = () => [ZoneDelegate];
5438 dart.setSignature(_ZoneDelegate, {
5439 constructors: () => ({_ZoneDelegate: [_ZoneDelegate, [_Zone]]}),
5440 methods: () => ({
5441 handleUncaughtError: [dart.dynamic, [Zone, dart.dynamic, core.StackTrace]] ,
5442 run: [dart.dynamic, [Zone, dart.functionType(dart.dynamic, [])]],
5443 runUnary: [dart.dynamic, [Zone, dart.functionType(dart.dynamic, [dart.dyna mic]), dart.dynamic]],
5444 runBinary: [dart.dynamic, [Zone, dart.functionType(dart.dynamic, [dart.dyn amic, dart.dynamic]), dart.dynamic, dart.dynamic]],
5445 registerCallback: [ZoneCallback, [Zone, dart.functionType(dart.dynamic, [] )]],
5446 registerUnaryCallback: [ZoneUnaryCallback, [Zone, dart.functionType(dart.d ynamic, [dart.dynamic])]],
5447 registerBinaryCallback: [ZoneBinaryCallback, [Zone, dart.functionType(dart .dynamic, [dart.dynamic, dart.dynamic])]],
5448 errorCallback: [AsyncError, [Zone, core.Object, core.StackTrace]],
5449 scheduleMicrotask: [dart.void, [Zone, dart.functionType(dart.dynamic, [])] ],
5450 createTimer: [Timer, [Zone, core.Duration, dart.functionType(dart.void, [] )]],
5451 createPeriodicTimer: [Timer, [Zone, core.Duration, dart.functionType(dart. void, [Timer])]],
5452 print: [dart.void, [Zone, core.String]],
5453 fork: [Zone, [Zone, ZoneSpecification, core.Map]]
5454 })
5455 });
5456 let _delegateCache = Symbol('_delegateCache');
5457 class _CustomZone extends _Zone {
5458 get [_delegate]() {
5459 if (this[_delegateCache] != null)
5460 return this[_delegateCache];
5461 this[_delegateCache] = new _ZoneDelegate(this);
5462 return this[_delegateCache];
5463 }
5464 _CustomZone(parent, specification, map) {
5465 this.parent = parent;
5466 this[_map] = map;
5467 this[_runUnary] = null;
5468 this[_run] = null;
5469 this[_runBinary] = null;
5470 this[_registerCallback] = null;
5471 this[_registerUnaryCallback] = null;
5472 this[_registerBinaryCallback] = null;
5473 this[_errorCallback] = null;
5474 this[_scheduleMicrotask] = null;
5475 this[_createTimer] = null;
5476 this[_createPeriodicTimer] = null;
5477 this[_print] = null;
5478 this[_fork] = null;
5479 this[_handleUncaughtError] = null;
5480 this[_delegateCache] = null;
5481 super._Zone();
5482 this[_run] = specification.run != null ? new _ZoneFunction(this, specifica tion.run) : this.parent[_run];
5483 this[_runUnary] = specification.runUnary != null ? new _ZoneFunction(this, specification.runUnary) : this.parent[_runUnary];
5484 this[_runBinary] = specification.runBinary != null ? new _ZoneFunction(thi s, specification.runBinary) : this.parent[_runBinary];
5485 this[_registerCallback] = specification.registerCallback != null ? new _Zo neFunction(this, specification.registerCallback) : this.parent[_registerCallback ];
5486 this[_registerUnaryCallback] = specification.registerUnaryCallback != null ? new _ZoneFunction(this, specification.registerUnaryCallback) : this.parent[_r egisterUnaryCallback];
5487 this[_registerBinaryCallback] = specification.registerBinaryCallback != nu ll ? new _ZoneFunction(this, specification.registerBinaryCallback) : this.parent [_registerBinaryCallback];
5488 this[_errorCallback] = specification.errorCallback != null ? new _ZoneFunc tion(this, specification.errorCallback) : this.parent[_errorCallback];
5489 this[_scheduleMicrotask] = specification.scheduleMicrotask != null ? new _ ZoneFunction(this, specification.scheduleMicrotask) : this.parent[_scheduleMicro task];
5490 this[_createTimer] = specification.createTimer != null ? new _ZoneFunction (this, specification.createTimer) : this.parent[_createTimer];
5491 this[_createPeriodicTimer] = specification.createPeriodicTimer != null ? n ew _ZoneFunction(this, specification.createPeriodicTimer) : this.parent[_createP eriodicTimer];
5492 this[_print] = specification.print != null ? new _ZoneFunction(this, speci fication.print) : this.parent[_print];
5493 this[_fork] = specification.fork != null ? new _ZoneFunction(this, specifi cation.fork) : this.parent[_fork];
5494 this[_handleUncaughtError] = specification.handleUncaughtError != null ? n ew _ZoneFunction(this, specification.handleUncaughtError) : this.parent[_handleU ncaughtError];
5495 }
5496 get errorZone() {
5497 return this[_handleUncaughtError].zone;
5498 }
5499 runGuarded(f) {
5500 try {
5501 return this.run(f);
5502 } catch (e) {
5503 let s = dart.stackTrace(e);
5504 return this.handleUncaughtError(e, s);
5505 }
5506
5507 }
5508 runUnaryGuarded(f, arg) {
5509 try {
5510 return this.runUnary(f, arg);
5511 } catch (e) {
5512 let s = dart.stackTrace(e);
5513 return this.handleUncaughtError(e, s);
5514 }
5515
5516 }
5517 runBinaryGuarded(f, arg1, arg2) {
5518 try {
5519 return this.runBinary(f, arg1, arg2);
5520 } catch (e) {
5521 let s = dart.stackTrace(e);
5522 return this.handleUncaughtError(e, s);
5523 }
5524
5525 }
5526 bindCallback(f, opts) {
5527 let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
5528 let registered = this.registerCallback(f);
5529 if (dart.notNull(runGuarded)) {
5530 return dart.fn((() => this.runGuarded(registered)).bind(this));
5531 } else {
5532 return dart.fn((() => this.run(registered)).bind(this));
5533 }
5534 }
5535 bindUnaryCallback(f, opts) {
5536 let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
5537 let registered = this.registerUnaryCallback(f);
5538 if (dart.notNull(runGuarded)) {
5539 return dart.fn((arg => this.runUnaryGuarded(registered, arg)).bind(this) );
5540 } else {
5541 return dart.fn((arg => this.runUnary(registered, arg)).bind(this));
5542 }
5543 }
5544 bindBinaryCallback(f, opts) {
5545 let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
5546 let registered = this.registerBinaryCallback(f);
5547 if (dart.notNull(runGuarded)) {
5548 return dart.fn(((arg1, arg2) => this.runBinaryGuarded(registered, arg1, arg2)).bind(this));
5549 } else {
5550 return dart.fn(((arg1, arg2) => this.runBinary(registered, arg1, arg2)). bind(this));
5551 }
5552 }
5553 get(key) {
5554 let result = this[_map].get(key);
5555 if (result != null || dart.notNull(this[_map].containsKey(key)))
5556 return result;
5557 if (this.parent != null) {
5558 let value = this.parent.get(key);
5559 if (value != null) {
5560 this[_map].set(key, value);
5561 }
5562 return value;
5563 }
5564 dart.assert(dart.equals(this, _ROOT_ZONE));
5565 return null;
5566 }
5567 handleUncaughtError(error, stackTrace) {
5568 let implementation = this[_handleUncaughtError];
5569 dart.assert(implementation != null);
5570 let parentDelegate = _parentDelegate(implementation.zone);
5571 return dart.dcall(implementation.function, implementation.zone, parentDele gate, this, error, stackTrace);
5572 }
5573 fork(opts) {
5574 let specification = opts && 'specification' in opts ? opts.specification : null;
5575 let zoneValues = opts && 'zoneValues' in opts ? opts.zoneValues : null;
5576 let implementation = this[_fork];
5577 dart.assert(implementation != null);
5578 let parentDelegate = _parentDelegate(implementation.zone);
5579 return dart.as(dart.dcall(implementation.function, implementation.zone, pa rentDelegate, this, specification, zoneValues), Zone);
5580 }
5581 run(f) {
5582 let implementation = this[_run];
5583 dart.assert(implementation != null);
5584 let parentDelegate = _parentDelegate(implementation.zone);
5585 return dart.dcall(implementation.function, implementation.zone, parentDele gate, this, f);
5586 }
5587 runUnary(f, arg) {
5588 let implementation = this[_runUnary];
5589 dart.assert(implementation != null);
5590 let parentDelegate = _parentDelegate(implementation.zone);
5591 return dart.dcall(implementation.function, implementation.zone, parentDele gate, this, f, arg);
5592 }
5593 runBinary(f, arg1, arg2) {
5594 let implementation = this[_runBinary];
5595 dart.assert(implementation != null);
5596 let parentDelegate = _parentDelegate(implementation.zone);
5597 return dart.dcall(implementation.function, implementation.zone, parentDele gate, this, f, arg1, arg2);
5598 }
5599 registerCallback(f) {
5600 let implementation = this[_registerCallback];
5601 dart.assert(implementation != null);
5602 let parentDelegate = _parentDelegate(implementation.zone);
5603 return dart.as(dart.dcall(implementation.function, implementation.zone, pa rentDelegate, this, f), ZoneCallback);
5604 }
5605 registerUnaryCallback(f) {
5606 let implementation = this[_registerUnaryCallback];
5607 dart.assert(implementation != null);
5608 let parentDelegate = _parentDelegate(implementation.zone);
5609 return dart.as(dart.dcall(implementation.function, implementation.zone, pa rentDelegate, this, f), ZoneUnaryCallback);
5610 }
5611 registerBinaryCallback(f) {
5612 let implementation = this[_registerBinaryCallback];
5613 dart.assert(implementation != null);
5614 let parentDelegate = _parentDelegate(implementation.zone);
5615 return dart.as(dart.dcall(implementation.function, implementation.zone, pa rentDelegate, this, f), ZoneBinaryCallback);
5616 }
5617 errorCallback(error, stackTrace) {
5618 let implementation = this[_errorCallback];
5619 dart.assert(implementation != null);
5620 let implementationZone = implementation.zone;
5621 if (dart.notNull(core.identical(implementationZone, _ROOT_ZONE)))
5622 return null;
5623 let parentDelegate = _parentDelegate(dart.as(implementationZone, _Zone));
5624 return dart.as(dart.dcall(implementation.function, implementationZone, par entDelegate, this, error, stackTrace), AsyncError);
5625 }
5626 scheduleMicrotask(f) {
5627 let implementation = this[_scheduleMicrotask];
5628 dart.assert(implementation != null);
5629 let parentDelegate = _parentDelegate(implementation.zone);
5630 return dart.dcall(implementation.function, implementation.zone, parentDele gate, this, f);
5631 }
5632 createTimer(duration, f) {
5633 let implementation = this[_createTimer];
5634 dart.assert(implementation != null);
5635 let parentDelegate = _parentDelegate(implementation.zone);
5636 return dart.as(dart.dcall(implementation.function, implementation.zone, pa rentDelegate, this, duration, f), Timer);
5637 }
5638 createPeriodicTimer(duration, f) {
5639 let implementation = this[_createPeriodicTimer];
5640 dart.assert(implementation != null);
5641 let parentDelegate = _parentDelegate(implementation.zone);
5642 return dart.as(dart.dcall(implementation.function, implementation.zone, pa rentDelegate, this, duration, f), Timer);
5643 }
5644 print(line) {
5645 let implementation = this[_print];
5646 dart.assert(implementation != null);
5647 let parentDelegate = _parentDelegate(implementation.zone);
5648 return dart.dcall(implementation.function, implementation.zone, parentDele gate, this, line);
5649 }
5650 }
5651 dart.setSignature(_CustomZone, {
5652 constructors: () => ({_CustomZone: [_CustomZone, [_Zone, ZoneSpecification, core.Map]]}),
5653 methods: () => ({
5654 runGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [])]],
5655 runUnaryGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dyn amic]), dart.dynamic]],
5656 runBinaryGuarded: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dy namic, dart.dynamic]), dart.dynamic, dart.dynamic]],
5657 bindCallback: [ZoneCallback, [dart.functionType(dart.dynamic, [])], {runGu arded: core.bool}],
5658 bindUnaryCallback: [ZoneUnaryCallback, [dart.functionType(dart.dynamic, [d art.dynamic])], {runGuarded: core.bool}],
5659 bindBinaryCallback: [ZoneBinaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])], {runGuarded: core.bool}],
5660 get: [dart.dynamic, [core.Object]],
5661 handleUncaughtError: [dart.dynamic, [dart.dynamic, core.StackTrace]],
5662 fork: [Zone, [], {specification: ZoneSpecification, zoneValues: core.Map}] ,
5663 run: [dart.dynamic, [dart.functionType(dart.dynamic, [])]],
5664 runUnary: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]],
5665 runBinary: [dart.dynamic, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]],
5666 registerCallback: [ZoneCallback, [dart.functionType(dart.dynamic, [])]],
5667 registerUnaryCallback: [ZoneUnaryCallback, [dart.functionType(dart.dynamic , [dart.dynamic])]],
5668 registerBinaryCallback: [ZoneBinaryCallback, [dart.functionType(dart.dynam ic, [dart.dynamic, dart.dynamic])]],
5669 errorCallback: [AsyncError, [core.Object, core.StackTrace]],
5670 scheduleMicrotask: [dart.void, [dart.functionType(dart.void, [])]],
5671 createTimer: [Timer, [core.Duration, dart.functionType(dart.void, [])]],
5672 createPeriodicTimer: [Timer, [core.Duration, dart.functionType(dart.void, [Timer])]],
5673 print: [dart.void, [core.String]]
5674 })
5675 });
5676 function _rootHandleUncaughtError(self, parent, zone, error, stackTrace) {
5677 _schedulePriorityAsyncCallback(dart.fn(() => {
5678 dart.throw(new _UncaughtAsyncError(error, stackTrace));
5679 }));
5680 }
5681 dart.fn(_rootHandleUncaughtError, dart.void, [Zone, ZoneDelegate, Zone, dart.d ynamic, core.StackTrace]);
5682 function _rootRun(self, parent, zone, f) {
5683 if (dart.equals(Zone._current, zone))
5684 return f();
5685 let old = Zone._enter(zone);
5686 try {
5687 return f();
5688 } finally {
5689 Zone._leave(old);
5690 }
5691 }
5692 dart.fn(_rootRun, dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(d art.dynamic, [])]);
5693 function _rootRunUnary(self, parent, zone, f, arg) {
5694 if (dart.equals(Zone._current, zone))
5695 return dart.dcall(f, arg);
5696 let old = Zone._enter(zone);
5697 try {
5698 return dart.dcall(f, arg);
5699 } finally {
5700 Zone._leave(old);
5701 }
5702 }
5703 dart.fn(_rootRunUnary, dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionT ype(dart.dynamic, [dart.dynamic]), dart.dynamic]);
5704 function _rootRunBinary(self, parent, zone, f, arg1, arg2) {
5705 if (dart.equals(Zone._current, zone))
5706 return dart.dcall(f, arg1, arg2);
5707 let old = Zone._enter(zone);
5708 try {
5709 return dart.dcall(f, arg1, arg2);
5710 } finally {
5711 Zone._leave(old);
5712 }
5713 }
5714 dart.fn(_rootRunBinary, dart.dynamic, [Zone, ZoneDelegate, Zone, dart.function Type(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]);
5715 function _rootRegisterCallback(self, parent, zone, f) {
5716 return f;
5717 }
5718 dart.fn(_rootRegisterCallback, ZoneCallback, [Zone, ZoneDelegate, Zone, dart.f unctionType(dart.dynamic, [])]);
5719 function _rootRegisterUnaryCallback(self, parent, zone, f) {
5720 return f;
5721 }
5722 dart.fn(_rootRegisterUnaryCallback, ZoneUnaryCallback, [Zone, ZoneDelegate, Zo ne, dart.functionType(dart.dynamic, [dart.dynamic])]);
5723 function _rootRegisterBinaryCallback(self, parent, zone, f) {
5724 return f;
5725 }
5726 dart.fn(_rootRegisterBinaryCallback, ZoneBinaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]);
5727 function _rootErrorCallback(self, parent, zone, error, stackTrace) {
5728 return null;
5729 }
5730 dart.fn(_rootErrorCallback, AsyncError, [Zone, ZoneDelegate, Zone, core.Object , core.StackTrace]);
5731 function _rootScheduleMicrotask(self, parent, zone, f) {
5732 if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
5733 let hasErrorHandler = !dart.notNull(_ROOT_ZONE.inSameErrorZone(zone));
5734 f = zone.bindCallback(f, {runGuarded: hasErrorHandler});
5735 }
5736 _scheduleAsyncCallback(f);
5737 }
5738 dart.fn(_rootScheduleMicrotask, dart.void, [Zone, ZoneDelegate, Zone, dart.fun ctionType(dart.dynamic, [])]);
5739 function _rootCreateTimer(self, parent, zone, duration, callback) {
5740 if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
5741 callback = zone.bindCallback(callback);
5742 }
5743 return Timer._createTimer(duration, callback);
5744 }
5745 dart.fn(_rootCreateTimer, Timer, [Zone, ZoneDelegate, Zone, core.Duration, dar t.functionType(dart.void, [])]);
5746 function _rootCreatePeriodicTimer(self, parent, zone, duration, callback) {
5747 if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
5748 callback = dart.as(zone.bindUnaryCallback(callback), __CastType36);
5749 }
5750 return Timer._createPeriodicTimer(duration, callback);
5751 }
5752 dart.fn(_rootCreatePeriodicTimer, Timer, [Zone, ZoneDelegate, Zone, core.Durat ion, dart.functionType(dart.void, [Timer])]);
5753 function _rootPrint(self, parent, zone, line) {
5754 _internal.printToConsole(line);
5755 }
5756 dart.fn(_rootPrint, dart.void, [Zone, ZoneDelegate, Zone, core.String]);
5757 function _printToZone(line) {
5758 Zone.current.print(line);
5759 }
5760 dart.fn(_printToZone, dart.void, [core.String]);
5761 function _rootFork(self, parent, zone, specification, zoneValues) {
5762 _internal.printToZone = _printToZone;
5763 if (specification == null) {
5764 specification = dart.const(ZoneSpecification.new());
5765 } else if (!dart.is(specification, _ZoneSpecification)) {
5766 dart.throw(new core.ArgumentError("ZoneSpecifications must be instantiated " + " with the provided constructor."));
5767 }
5768 let valueMap = null;
5769 if (zoneValues == null) {
5770 if (dart.is(zone, _Zone)) {
5771 valueMap = zone[_map];
5772 } else {
5773 valueMap = collection.HashMap.new();
5774 }
5775 } else {
5776 valueMap = collection.HashMap.from(zoneValues);
5777 }
5778 return new _CustomZone(dart.as(zone, _Zone), specification, valueMap);
5779 }
5780 dart.fn(_rootFork, Zone, [Zone, ZoneDelegate, Zone, ZoneSpecification, core.Ma p]);
5781 class _RootZoneSpecification extends core.Object {
5782 get handleUncaughtError() {
5783 return _rootHandleUncaughtError;
5784 }
5785 get run() {
5786 return _rootRun;
5787 }
5788 get runUnary() {
5789 return _rootRunUnary;
5790 }
5791 get runBinary() {
5792 return _rootRunBinary;
5793 }
5794 get registerCallback() {
5795 return _rootRegisterCallback;
5796 }
5797 get registerUnaryCallback() {
5798 return _rootRegisterUnaryCallback;
5799 }
5800 get registerBinaryCallback() {
5801 return _rootRegisterBinaryCallback;
5802 }
5803 get errorCallback() {
5804 return _rootErrorCallback;
5805 }
5806 get scheduleMicrotask() {
5807 return _rootScheduleMicrotask;
5808 }
5809 get createTimer() {
5810 return _rootCreateTimer;
5811 }
5812 get createPeriodicTimer() {
5813 return _rootCreatePeriodicTimer;
5814 }
5815 get print() {
5816 return _rootPrint;
5817 }
5818 get fork() {
5819 return _rootFork;
5820 }
5821 }
5822 _RootZoneSpecification[dart.implements] = () => [ZoneSpecification];
5823 _RootZone._rootDelegate = null;
5824 dart.defineLazyProperties(_RootZone, {
5825 get _rootMap() {
5826 return collection.HashMap.new();
5827 },
5828 set _rootMap(_) {}
5829 });
5830 function runZoned(body, opts) {
5831 let zoneValues = opts && 'zoneValues' in opts ? opts.zoneValues : null;
5832 let zoneSpecification = opts && 'zoneSpecification' in opts ? opts.zoneSpeci fication : null;
5833 let onError = opts && 'onError' in opts ? opts.onError : null;
5834 let errorHandler = null;
5835 if (onError != null) {
5836 errorHandler = dart.fn((self, parent, zone, error, stackTrace) => {
5837 try {
5838 if (dart.is(onError, ZoneBinaryCallback)) {
5839 return self.parent.runBinary(onError, error, stackTrace);
5840 }
5841 return self.parent.runUnary(dart.as(onError, __CastType38), error);
5842 } catch (e) {
5843 let s = dart.stackTrace(e);
5844 if (dart.notNull(core.identical(e, error))) {
5845 return parent.handleUncaughtError(zone, error, stackTrace);
5846 } else {
5847 return parent.handleUncaughtError(zone, e, s);
5848 }
5849 }
5850
5851 }, dart.dynamic, [Zone, ZoneDelegate, Zone, dart.dynamic, core.StackTrace] );
5852 }
5853 if (zoneSpecification == null) {
5854 zoneSpecification = ZoneSpecification.new({handleUncaughtError: errorHandl er});
5855 } else if (errorHandler != null) {
5856 zoneSpecification = ZoneSpecification.from(zoneSpecification, {handleUncau ghtError: errorHandler});
5857 }
5858 let zone = Zone.current.fork({specification: zoneSpecification, zoneValues: zoneValues});
5859 if (onError != null) {
5860 return zone.runGuarded(body);
5861 } else {
5862 return zone.run(body);
5863 }
5864 }
5865 dart.fn(runZoned, dart.dynamic, [dart.functionType(dart.dynamic, [])], {zoneVa lues: core.Map, zoneSpecification: ZoneSpecification, onError: core.Function});
5866 let __CastType36 = dart.typedef('__CastType36', () => dart.functionType(dart.v oid, [Timer]));
5867 let __CastType38 = dart.typedef('__CastType38', () => dart.functionType(dart.d ynamic, [dart.dynamic]));
5868 dart.copyProperties(exports, {
5869 get _hasDocument() {
5870 return typeof document == 'object';
5871 }
5872 });
5873 // Exports:
5874 exports.AsyncError = AsyncError;
5875 exports.Stream$ = Stream$;
5876 exports.Stream = Stream;
5877 exports.DeferredLibrary = DeferredLibrary;
5878 exports.DeferredLoadException = DeferredLoadException;
5879 exports.Future$ = Future$;
5880 exports.Future = Future;
5881 exports.TimeoutException = TimeoutException;
5882 exports.Completer$ = Completer$;
5883 exports.Completer = Completer;
5884 exports.scheduleMicrotask = scheduleMicrotask;
5885 exports.StreamSubscription$ = StreamSubscription$;
5886 exports.StreamSubscription = StreamSubscription;
5887 exports.EventSink$ = EventSink$;
5888 exports.EventSink = EventSink;
5889 exports.StreamView$ = StreamView$;
5890 exports.StreamView = StreamView;
5891 exports.StreamConsumer$ = StreamConsumer$;
5892 exports.StreamConsumer = StreamConsumer;
5893 exports.StreamSink$ = StreamSink$;
5894 exports.StreamSink = StreamSink;
5895 exports.StreamTransformer$ = StreamTransformer$;
5896 exports.StreamTransformer = StreamTransformer;
5897 exports.StreamIterator$ = StreamIterator$;
5898 exports.StreamIterator = StreamIterator;
5899 exports.StreamController$ = StreamController$;
5900 exports.StreamController = StreamController;
5901 exports.Timer = Timer;
5902 exports.ZoneCallback = ZoneCallback;
5903 exports.ZoneUnaryCallback = ZoneUnaryCallback;
5904 exports.ZoneBinaryCallback = ZoneBinaryCallback;
5905 exports.HandleUncaughtErrorHandler = HandleUncaughtErrorHandler;
5906 exports.RunHandler = RunHandler;
5907 exports.RunUnaryHandler = RunUnaryHandler;
5908 exports.RunBinaryHandler = RunBinaryHandler;
5909 exports.RegisterCallbackHandler = RegisterCallbackHandler;
5910 exports.RegisterUnaryCallbackHandler = RegisterUnaryCallbackHandler;
5911 exports.RegisterBinaryCallbackHandler = RegisterBinaryCallbackHandler;
5912 exports.ErrorCallbackHandler = ErrorCallbackHandler;
5913 exports.ScheduleMicrotaskHandler = ScheduleMicrotaskHandler;
5914 exports.CreateTimerHandler = CreateTimerHandler;
5915 exports.CreatePeriodicTimerHandler = CreatePeriodicTimerHandler;
5916 exports.PrintHandler = PrintHandler;
5917 exports.ForkHandler = ForkHandler;
5918 exports.ZoneSpecification = ZoneSpecification;
5919 exports.ZoneDelegate = ZoneDelegate;
5920 exports.Zone = Zone;
5921 exports.runZoned = runZoned;
5922 });
OLDNEW
« no previous file with comments | « lib/runtime/dart/_native_typed_data.js ('k') | lib/runtime/dart/collection.js » ('j') | lib/src/checker/resolver.dart » ('J')

Powered by Google App Engine
This is Rietveld 408576698